diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 000000000..587b786e4 --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +*.json -diff diff --git a/src/Analysis/Ast/Impl/Analyzer/Definitions/IPythonAnalyzer.cs b/src/Analysis/Ast/Impl/Analyzer/Definitions/IPythonAnalyzer.cs index 970c4bb3f..1e77bcb22 100644 --- a/src/Analysis/Ast/Impl/Analyzer/Definitions/IPythonAnalyzer.cs +++ b/src/Analysis/Ast/Impl/Analyzer/Definitions/IPythonAnalyzer.cs @@ -56,10 +56,11 @@ public interface IPythonAnalyzer { /// IReadOnlyList LintModule(IPythonModule module); + /// - /// Removes all the modules from the analysis, except Typeshed and builtin + /// Removes all the modules from the analysis and restarts it, including stubs. /// - void ResetAnalyzer(); + Task ResetAnalyzer(); /// /// Returns list of currently loaded modules. diff --git a/src/Analysis/Ast/Impl/Analyzer/Evaluation/ExpressionEval.Constants.cs b/src/Analysis/Ast/Impl/Analyzer/Evaluation/ExpressionEval.Constants.cs index 53376c5a0..52185a35c 100644 --- a/src/Analysis/Ast/Impl/Analyzer/Evaluation/ExpressionEval.Constants.cs +++ b/src/Analysis/Ast/Impl/Analyzer/Evaluation/ExpressionEval.Constants.cs @@ -23,7 +23,7 @@ namespace Microsoft.Python.Analysis.Analyzer.Evaluation { internal sealed partial class ExpressionEval { - public IPythonInstance GetConstantFromLiteral(Expression expr, LookupOptions options) { + public IPythonInstance GetConstantFromLiteral(Expression expr) { if (expr is ConstantExpression ce) { switch (ce.Value) { case string s: diff --git a/src/Analysis/Ast/Impl/Analyzer/Evaluation/ExpressionEval.cs b/src/Analysis/Ast/Impl/Analyzer/Evaluation/ExpressionEval.cs index 23b6e498c..dceef6fd7 100644 --- a/src/Analysis/Ast/Impl/Analyzer/Evaluation/ExpressionEval.cs +++ b/src/Analysis/Ast/Impl/Analyzer/Evaluation/ExpressionEval.cs @@ -189,7 +189,7 @@ public IMember GetValueFromExpression(Expression expr, LookupOptions options = L m = null; break; default: - m = GetValueFromBinaryOp(expr) ?? GetConstantFromLiteral(expr, options); + m = GetValueFromBinaryOp(expr) ?? GetConstantFromLiteral(expr); break; } if (m == null) { @@ -237,22 +237,12 @@ private IMember GetValueFromMember(MemberExpression expr) { return null; } - IPythonInstance instance = null; var m = GetValueFromExpression(expr.Target); - if (m is IPythonType typeInfo) { - var member = typeInfo.GetMember(expr.Name); - // If container is class/type info rather than the instance, then the method is an unbound function. - // Example: C.f where f is a method of C. Compare to C().f where f is bound to the instance of C. - if (member is PythonFunctionType f && !f.IsStatic && !f.IsClassMethod) { - f.AddReference(GetLocationOfName(expr)); - return f.ToUnbound(); - } - instance = new PythonInstance(typeInfo); + if (m == null) { + return UnknownType; } - instance = instance ?? m as IPythonInstance; - var type = m?.GetPythonType(); // Try inner type - + var type = m.GetPythonType(); var value = type?.GetMember(expr.Name); type?.AddMemberReference(expr.Name, this, GetLocationOfName(expr)); @@ -260,6 +250,19 @@ private IMember GetValueFromMember(MemberExpression expr) { return value; } + IPythonInstance instance = null; + if (m == type) { + // If container is class/type info rather than the instance, then the method is an unbound function. + // Example: C.f where f is a method of C. Compare to C().f where f is bound to the instance of C. + if (value is PythonFunctionType f && f.DeclaringType != null && !f.IsStatic && !f.IsClassMethod) { + f.AddReference(GetLocationOfName(expr)); + return f.ToUnbound(); + } + instance = new PythonInstance(type); + } + + instance = instance ?? m as IPythonInstance; + // Class type GetMember returns a type. However, class members are // mostly instances (consider self.x = 1, x is an instance of int). // However, it is indeed possible to have them as types, like in diff --git a/src/Analysis/Ast/Impl/Analyzer/Handlers/ConditionalHandler.cs b/src/Analysis/Ast/Impl/Analyzer/Handlers/ConditionalHandler.cs index 8720bc8e3..93c82cfd6 100644 --- a/src/Analysis/Ast/Impl/Analyzer/Handlers/ConditionalHandler.cs +++ b/src/Analysis/Ast/Impl/Analyzer/Handlers/ConditionalHandler.cs @@ -13,123 +13,18 @@ // See the Apache Version 2.0 License for specific language governing // permissions and limitations under the License. -using System; -using System.Linq; using Microsoft.Python.Core.OS; -using Microsoft.Python.Parsing; using Microsoft.Python.Parsing.Ast; namespace Microsoft.Python.Analysis.Analyzer.Handlers { internal sealed class ConditionalHandler : StatementHandler { private readonly IOSPlatform _platformService; - private enum ConditionTestResult { - Unrecognized, - DontWalkBody, - WalkBody - } - public ConditionalHandler(AnalysisWalker walker) : base(walker) { _platformService = Eval.Services.GetService(); } - public bool HandleIf(IfStatement node) { - // System version, platform and os.path specializations - var someRecognized = false; - foreach (var test in node.Tests) { - var result = TryHandleSysVersionInfo(test); - if (result != ConditionTestResult.Unrecognized) { - if (result == ConditionTestResult.WalkBody) { - test.Walk(Walker); - } - someRecognized = true; - continue; - } - - result = TryHandleSysPlatform(test); - if (result != ConditionTestResult.Unrecognized) { - if (result == ConditionTestResult.WalkBody) { - test.Walk(Walker); - } - someRecognized = true; - continue; - } - - result = TryHandleOsPath(test); - if (result != ConditionTestResult.Unrecognized) { - if (result == ConditionTestResult.WalkBody) { - test.Walk(Walker); - return false; // Execute only one condition. - } - someRecognized = true; - } - } - return !someRecognized; - } - - private ConditionTestResult TryHandleSysVersionInfo(IfStatementTest test) { - if (test.Test is BinaryExpression cmp && - cmp.Left is MemberExpression me && (me.Target as NameExpression)?.Name == "sys" && me.Name == "version_info" && - cmp.Right is TupleExpression te && te.Items.All(i => (i as ConstantExpression)?.Value is int)) { - Version v; - try { - v = new Version( - (int)((te.Items.ElementAtOrDefault(0) as ConstantExpression)?.Value ?? 0), - (int)((te.Items.ElementAtOrDefault(1) as ConstantExpression)?.Value ?? 0) - ); - } catch (ArgumentException) { - // Unsupported comparison, so walk all children - return ConditionTestResult.WalkBody; - } - - var shouldWalk = false; - switch (cmp.Operator) { - case PythonOperator.LessThan: - shouldWalk = Ast.LanguageVersion.ToVersion() < v; - break; - case PythonOperator.LessThanOrEqual: - shouldWalk = Ast.LanguageVersion.ToVersion() <= v; - break; - case PythonOperator.GreaterThan: - shouldWalk = Ast.LanguageVersion.ToVersion() > v; - break; - case PythonOperator.GreaterThanOrEqual: - shouldWalk = Ast.LanguageVersion.ToVersion() >= v; - break; - } - return shouldWalk ? ConditionTestResult.WalkBody : ConditionTestResult.DontWalkBody; - } - return ConditionTestResult.Unrecognized; - } - - private ConditionTestResult TryHandleSysPlatform(IfStatementTest test) { - if (test.Test is BinaryExpression cmp && - cmp.Left is MemberExpression me && (me.Target as NameExpression)?.Name == "sys" && me.Name == "platform" && - cmp.Right is ConstantExpression cex && cex.GetStringValue() is string s) { - switch (cmp.Operator) { - case PythonOperator.Equals: - return s == "win32" && _platformService.IsWindows ? ConditionTestResult.WalkBody : ConditionTestResult.DontWalkBody; - case PythonOperator.NotEquals: - return s == "win32" && _platformService.IsWindows ? ConditionTestResult.DontWalkBody : ConditionTestResult.WalkBody; - } - return ConditionTestResult.DontWalkBody; - } - return ConditionTestResult.Unrecognized; - } - - private ConditionTestResult TryHandleOsPath(IfStatementTest test) { - if (test.Test is BinaryExpression cmp && - cmp.Left is ConstantExpression cex && cex.GetStringValue() is string s && - cmp.Right is NameExpression nex && nex.Name == "_names") { - switch (cmp.Operator) { - case PythonOperator.In when s == "nt": - return _platformService.IsWindows ? ConditionTestResult.WalkBody : ConditionTestResult.DontWalkBody; - case PythonOperator.In when s == "posix": - return _platformService.IsWindows ? ConditionTestResult.DontWalkBody : ConditionTestResult.WalkBody; - } - return ConditionTestResult.DontWalkBody; - } - return ConditionTestResult.Unrecognized; - } + public bool HandleIf(IfStatement node) + => node.WalkIfWithSystemConditions(Walker, Ast.LanguageVersion, _platformService.IsWindows); } } diff --git a/src/Analysis/Ast/Impl/Analyzer/LibraryAnalysis.cs b/src/Analysis/Ast/Impl/Analyzer/LibraryAnalysis.cs index bf8f7df93..a68fe2642 100644 --- a/src/Analysis/Ast/Impl/Analyzer/LibraryAnalysis.cs +++ b/src/Analysis/Ast/Impl/Analyzer/LibraryAnalysis.cs @@ -15,12 +15,9 @@ using System.Collections.Generic; using System.Linq; -using Microsoft.Python.Analysis.Analyzer.Evaluation; using Microsoft.Python.Analysis.Diagnostics; using Microsoft.Python.Analysis.Documents; -using Microsoft.Python.Analysis.Modules; using Microsoft.Python.Analysis.Values; -using Microsoft.Python.Core; using Microsoft.Python.Core.Diagnostics; using Microsoft.Python.Parsing.Ast; diff --git a/src/Analysis/Ast/Impl/Analyzer/ModuleWalker.cs b/src/Analysis/Ast/Impl/Analyzer/ModuleWalker.cs index 87834d78d..a2c1759b9 100644 --- a/src/Analysis/Ast/Impl/Analyzer/ModuleWalker.cs +++ b/src/Analysis/Ast/Impl/Analyzer/ModuleWalker.cs @@ -16,6 +16,7 @@ using System.Collections.Generic; using System.Diagnostics; using System.Linq; +using System.Xml.Serialization; using Microsoft.Python.Analysis.Analyzer.Evaluation; using Microsoft.Python.Analysis.Documents; using Microsoft.Python.Analysis.Modules; @@ -227,8 +228,9 @@ private void MergeStub() { if (_stubAnalysis == null) { return; } - - var builtins = Module.Interpreter.ModuleResolution.BuiltinsModule; + // TODO: figure out why module is getting analyzed before stub. + // https://github.com/microsoft/python-language-server/issues/907 + // Debug.Assert(!(_stubAnalysis is EmptyAnalysis)); // Note that scrape can pick up more functions than the stub contains // Or the stub can have definitions that scraping had missed. Therefore @@ -242,57 +244,152 @@ private void MergeStub() { var sourceVar = Eval.GlobalScope.Variables[v.Name]; var sourceType = sourceVar?.Value.GetPythonType(); - + // If stub says 'Any' but we have better type, keep the current type. if (!IsStubBetterType(sourceType, stubType)) { - continue;; + continue; } - // If types are the classes, merge members. - // Otherwise, replace type from one from the stub. - if (sourceType is PythonClassType cls && Module.Equals(cls.DeclaringModule)) { - // If class exists and belongs to this module, add or replace - // its members with ones from the stub, preserving documentation. - // Don't augment types that do not come from this module. - foreach (var name in stubType.GetMemberNames()) { - var stubMember = stubType.GetMember(name); - var member = cls.GetMember(name); - - var memberType = member?.GetPythonType(); - var stubMemberType = stubMember.GetPythonType(); - - if (builtins.Equals(memberType?.DeclaringModule) || builtins.Equals(stubMemberType.DeclaringModule)) { - continue; // Leave builtins alone. + // If type does not exist in module, but exists in stub, declare it unless it is an import. + // If types are the classes, merge members. Otherwise, replace type from one from the stub. + switch (sourceType) { + case null: + // Nothing in sources, but there is type in the stub. Declare it. + if (v.Source == VariableSource.Declaration) { + Eval.DeclareVariable(v.Name, v.Value, v.Source); + } + break; + + case PythonClassType cls when Module.Equals(cls.DeclaringModule): + // Transfer documentation first so we get class documentation + // that came from class definition win over one that may + // come from __init__ during the member merge below. + TransferDocumentationAndLocation(sourceType, stubType); + + // If class exists and belongs to this module, add or replace + // its members with ones from the stub, preserving documentation. + // Don't augment types that do not come from this module. + // Do not replace __class__ since it has to match class type and we are not + // replacing class type, we are only merging members. + foreach (var name in stubType.GetMemberNames().Except(new[] { "__class__", "__base__", "__bases__", "__mro__", "mro" })) { + var stubMember = stubType.GetMember(name); + var member = cls.GetMember(name); + + var memberType = member?.GetPythonType(); + var stubMemberType = stubMember.GetPythonType(); + + if (sourceType.IsBuiltin || stubType.IsBuiltin) { + // If stub type does not have an immediate member such as __init__() and + // rather have it inherited from object, we do not want to use the inherited + // since current class may either have its own of inherits it from the object. + continue; + } + + if (stubMemberType?.MemberType == PythonMemberType.Method && stubMemberType?.DeclaringModule.ModuleType == ModuleType.Builtins) { + // Leave methods coming from object at the object and don't copy them into the derived class. + } + + if (!IsStubBetterType(memberType, stubMemberType)) { + continue; + } + + // Get documentation from the current type, if any, since stubs + // typically do not contain documentation while scraped code does. + TransferDocumentationAndLocation(memberType, stubMemberType); + cls.AddMember(name, stubMember, overwrite: true); } - if (!IsStubBetterType(memberType, stubMemberType)) { - continue; + break; + + case IPythonModule _: + // We do not re-declare modules. + break; + + default: + var stubModule = stubType.DeclaringModule; + if (stubType is IPythonModule || stubModule.ModuleType == ModuleType.Builtins) { + // Modules members that are modules should remain as they are, i.e. os.path + // should remain library with its own stub attached. + break; + } + // We do not re-declaring variables that are imported. + if (v.Source == VariableSource.Declaration) { + // Re-declare variable with the data from the stub. + TransferDocumentationAndLocation(sourceType, stubType); + // TODO: choose best type between the scrape and the stub. Stub probably should always win. + var source = Eval.CurrentScope.Variables[v.Name]?.Source ?? v.Source; + Eval.DeclareVariable(v.Name, v.Value, source); } - // Get documentation from the current type, if any, since stubs - // typically do not contain documentation while scraped code does. - memberType?.TransferDocumentationAndLocation(stubMemberType); - cls.AddMember(name, stubMember, overwrite: true); - } - } else { - // Re-declare variable with the data from the stub unless member is a module. - // Modules members that are modules should remain as they are, i.e. os.path - // should remain library with its own stub attached. - if (!(stubType is IPythonModule) && !builtins.Equals(stubType.DeclaringModule)) { - sourceType.TransferDocumentationAndLocation(stubType); - // TODO: choose best type between the scrape and the stub. Stub probably should always win. - var source = Eval.CurrentScope.Variables[v.Name]?.Source ?? VariableSource.Declaration; - Eval.DeclareVariable(v.Name, v.Value, source); - } + break; } } } private static bool IsStubBetterType(IPythonType sourceType, IPythonType stubType) { - // If stub says 'Any' but we have better type, keep the current type. if (stubType.IsUnknown()) { + // Do not use worse types than what is in the module. + return false; + } + if (sourceType.IsUnknown()) { + return true; // Anything is better than unknowns. + } + if (sourceType.DeclaringModule.ModuleType == ModuleType.Specialized) { + // Types in specialized modules should never be touched. + return false; + } + if (stubType.DeclaringModule is TypingModule && stubType.Name == "Any") { + // If stub says 'Any' but we have better type, keep the current type. return false; } - return sourceType.IsUnknown() || !(stubType.DeclaringModule is TypingModule) || stubType.Name != "Any"; + // Types should be compatible except it is allowed to replace function by a class. + // Consider stub of threading that replaces def RLock(): by class RLock(). + // Similarly, in _json, make_scanner function is replaced by a class. + if (sourceType.MemberType == PythonMemberType.Function && stubType.MemberType == PythonMemberType.Class) { + return true; + } + return sourceType.MemberType == stubType.MemberType; + } + + private static void TransferDocumentationAndLocation(IPythonType s, IPythonType d) { + if (s.IsUnknown() || d.IsBuiltin || s.IsBuiltin) { + return; // Do not transfer location of unknowns or builtins + } + // Documentation and location are always get transferred from module type + // to the stub type and never the other way around. This makes sure that + // we show documentation from the original module and goto definition + // navigates to the module source and not to the stub. + if (s != d && s is PythonType src && d is PythonType dst) { + // If type is a class, then doc can either come from class definition node of from __init__. + // If class has doc from the class definition, don't stomp on it. + var transferDoc = true; + if (src is PythonClassType srcClass && dst is PythonClassType dstClass) { + // Higher lever source wins + if(srcClass.DocumentationSource == PythonClassType.ClassDocumentationSource.Class || + (srcClass.DocumentationSource == PythonClassType.ClassDocumentationSource.Init && dstClass.DocumentationSource == PythonClassType.ClassDocumentationSource.Base)) { + dstClass.SetDocumentation(srcClass.Documentation); + transferDoc = false; + } + } + + // Sometimes destination (stub type) already has documentation. This happens when stub type + // is used to augment more than one type. For example, in threading module RLock stub class + // replaces both RLock function and _RLock class making 'factory' function RLock to look + // like a class constructor. Effectively a single stub type is used for more than one type + // in the source and two source types may have different documentation. Thus transferring doc + // from one source type affects documentation of another type. It may be better to clone stub + // type and separate instances for separate source type, but for now we'll just avoid stomping + // on the existing documentation. + if (transferDoc && string.IsNullOrEmpty(dst.Documentation)) { + var srcDocumentation = src.Documentation; + if (!string.IsNullOrEmpty(srcDocumentation)) { + dst.SetDocumentation(srcDocumentation); + } + } + + if (src.Location.IsValid) { + dst.Location = src.Location; + } + } } } } diff --git a/src/Analysis/Ast/Impl/Analyzer/PythonAnalyzer.cs b/src/Analysis/Ast/Impl/Analyzer/PythonAnalyzer.cs index c5d207f2a..7bae2ca29 100644 --- a/src/Analysis/Ast/Impl/Analyzer/PythonAnalyzer.cs +++ b/src/Analysis/Ast/Impl/Analyzer/PythonAnalyzer.cs @@ -17,7 +17,6 @@ using System.Collections.Generic; using System.Diagnostics; using System.Linq; -using System.Text; using System.Threading; using System.Threading.Tasks; using Microsoft.Python.Analysis.Caching; @@ -49,6 +48,7 @@ public sealed class PythonAnalyzer : IPythonAnalyzer, IDisposable { private int _version; private PythonAnalyzerSession _currentSession; private PythonAnalyzerSession _nextSession; + private bool _forceGCOnNextSession; public PythonAnalyzer(IServiceManager services, string cacheFolderPath = null) { _services = services; @@ -198,9 +198,18 @@ public IReadOnlyList LintModule(IPythonModule module) { return optionsProvider?.Options?.LintingEnabled == false ? Array.Empty() : result; } - public void ResetAnalyzer() { + public async Task ResetAnalyzer() { + var interpreter = _services.GetService(); + var builtins = interpreter.ModuleResolution.BuiltinsModule; + builtins.SetAst(builtins.Analysis.Ast); + + await interpreter.TypeshedResolution.ReloadAsync(); + await interpreter.ModuleResolution.ReloadAsync(); + lock (_syncObj) { - _analysisEntries.Split(kvp => kvp.Key.IsTypeshed || kvp.Value.Module is IBuiltinsPythonModule, out var entriesToPreserve, out var entriesToRemove); + _forceGCOnNextSession = true; + + _analysisEntries.Split(kvp => kvp.Value.Module is IBuiltinsPythonModule, out var entriesToPreserve, out var entriesToRemove); _analysisEntries.Clear(); foreach (var (key, entry) in entriesToPreserve) { _analysisEntries.Add(key, entry); @@ -208,6 +217,8 @@ public void ResetAnalyzer() { _dependencyResolver.RemoveKeys(entriesToRemove.Select(e => e.Key)); } + + _services.GetService().ReloadAll(); } public IReadOnlyList LoadedModules { @@ -220,7 +231,7 @@ public IReadOnlyList LoadedModules { public event EventHandler AnalysisComplete; - internal void RaiseAnalysisComplete(int moduleCount, double msElapsed) + internal void RaiseAnalysisComplete(int moduleCount, double msElapsed) => AnalysisComplete?.Invoke(this, new AnalysisCompleteEventArgs(moduleCount, msElapsed)); private void AnalyzeDocument(in AnalysisModuleKey key, in PythonAnalyzerEntry entry, in ImmutableArray dependencies) { @@ -243,7 +254,7 @@ private void AnalyzeDocument(in AnalysisModuleKey key, in PythonAnalyzerEntry en session.Start(true); } } - + private bool TryCreateSession(in int graphVersion, in PythonAnalyzerEntry entry, out PythonAnalyzerSession session) { var analyzeUserModuleOutOfOrder = false; lock (_syncObj) { @@ -278,7 +289,7 @@ private bool TryCreateSession(in int graphVersion, in PythonAnalyzerEntry entry, session = null; return false; } - + if (_currentSession.IsCompleted) { _currentSession = session = CreateSession(walker, null); return true; @@ -303,14 +314,21 @@ private void StartNextSession(Task task) { session.Start(false); } - private PythonAnalyzerSession CreateSession(in IDependencyChainWalker walker, in PythonAnalyzerEntry entry) - => new PythonAnalyzerSession(_services, _progress, _analysisCompleteEvent, _startNextSession, _disposeToken.CancellationToken, walker, _version, entry); + private PythonAnalyzerSession CreateSession(in IDependencyChainWalker walker, in PythonAnalyzerEntry entry) { + bool forceGC; + lock (_syncObj) { + forceGC = _forceGCOnNextSession; + _forceGCOnNextSession = false; + } + + return new PythonAnalyzerSession(_services, _progress, _analysisCompleteEvent, _startNextSession, _disposeToken.CancellationToken, walker, _version, entry, forceGC: forceGC); + } private void LoadMissingDocuments(IPythonInterpreter interpreter, ImmutableArray missingKeys) { if (missingKeys.Count == 0) { return; } - + var foundKeys = ImmutableArray.Empty; foreach (var missingKey in missingKeys) { lock (_syncObj) { diff --git a/src/Analysis/Ast/Impl/Analyzer/PythonAnalyzerSession.cs b/src/Analysis/Ast/Impl/Analyzer/PythonAnalyzerSession.cs index 753a3ef92..7fdfeaa76 100644 --- a/src/Analysis/Ast/Impl/Analyzer/PythonAnalyzerSession.cs +++ b/src/Analysis/Ast/Impl/Analyzer/PythonAnalyzerSession.cs @@ -46,7 +46,7 @@ internal sealed class PythonAnalyzerSession { private readonly IProgressReporter _progress; private readonly IPythonAnalyzer _analyzer; private readonly ILogger _log; - private readonly ITelemetryService _telemetry; + private readonly bool _forceGC; private readonly IModuleDatabaseService _moduleDatabaseService; private State _state; @@ -71,7 +71,8 @@ public PythonAnalyzerSession(IServiceManager services, CancellationToken analyzerCancellationToken, IDependencyChainWalker walker, int version, - PythonAnalyzerEntry entry) { + PythonAnalyzerEntry entry, + bool forceGC = false) { _services = services; _analysisCompleteEvent = analysisCompleteEvent; @@ -82,11 +83,11 @@ public PythonAnalyzerSession(IServiceManager services, _walker = walker; _entry = entry; _state = State.NotStarted; + _forceGC = forceGC; _diagnosticsService = _services.GetService(); _analyzer = _services.GetService(); _log = _services.GetService(); - _telemetry = _services.GetService(); _moduleDatabaseService = _services.GetService(); _progress = progress; } @@ -161,11 +162,12 @@ private async Task StartAsync() { var elapsed = stopWatch.Elapsed.TotalMilliseconds; LogResults(_log, elapsed, originalRemaining, remaining, Version); - ForceGCIfNeeded(originalRemaining, remaining); + ForceGCIfNeeded(_log, originalRemaining, remaining, _forceGC); } - private static void ForceGCIfNeeded(int originalRemaining, int remaining) { - if (originalRemaining - remaining > 1000) { + private static void ForceGCIfNeeded(ILogger logger, int originalRemaining, int remaining, bool force) { + if (force || originalRemaining - remaining > 1000) { + logger?.Log(TraceEventType.Verbose, "Forcing full garbage collection and heap compaction."); GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce; GC.Collect(); } @@ -232,7 +234,7 @@ private async Task AnalyzeAffectedEntriesAsync(Stopwatch stopWatch) { } - private bool IsAnalyzedLibraryInLoop(IDependencyChainNode node) + private bool IsAnalyzedLibraryInLoop(IDependencyChainNode node) => !node.HasMissingDependencies && node.Value.IsAnalyzedLibrary(_walker.Version) && node.IsWalkedWithDependencies && node.IsValidVersion; private Task StartAnalysis(IDependencyChainNode node, AsyncCountdownEvent ace, Stopwatch stopWatch) @@ -370,10 +372,26 @@ private void LogException(IPythonModule module, Exception exception) { } private IDocumentAnalysis CreateAnalysis(IDependencyChainNode node, IDocument document, PythonAst ast, int version, ModuleWalker walker, bool isCanceled) { + var canHaveLibraryAnalysis = false; + var saveAnalysis = false; + // Don't try to drop builtins; it causes issues elsewhere. + // We probably want the builtin module's AST and other info for evaluation. + switch (document.ModuleType) { + case ModuleType.Library: + case ModuleType.Compiled: + case ModuleType.CompiledBuiltin: + canHaveLibraryAnalysis = true; + saveAnalysis = true; + break; + case ModuleType.Stub: + canHaveLibraryAnalysis = true; + break; + } + var createLibraryAnalysis = !isCanceled && node != null && !node.HasMissingDependencies && - document.ModuleType == ModuleType.Library && + canHaveLibraryAnalysis && !document.IsOpen && node.HasOnlyWalkedDependencies && node.IsValidVersion; @@ -388,7 +406,10 @@ private IDocumentAnalysis CreateAnalysis(IDependencyChainNode(); - if (Module.ModuleType != ModuleType.User && optionsProvider?.Options.KeepLibraryLocalVariables != true) { + if (Module.ModuleType != ModuleType.User && + optionsProvider?.Options.KeepLibraryLocalVariables != true && + Eval.CurrentScope.Variables.All( + v => v.GetPythonType() == null && + v.GetPythonType() == null) + ) { ((VariableCollection)Eval.CurrentScope.Variables).Clear(); } } @@ -79,6 +85,7 @@ private IPythonType TryDetermineReturnValue() { if (!annotationType.IsUnknown()) { // Annotations are typically types while actually functions return // instances unless specifically annotated to a type such as Type[T]. + // TODO: try constructing argument set from types. Consider Tuple[_T1, _T2] where _T1 = TypeVar('_T1', str, bytes) var t = annotationType.CreateInstance(annotationType.Name, ArgumentSet.WithoutContext); // If instance could not be created, such as when return type is List[T] and // type of T is not yet known, just use the type. @@ -119,8 +126,8 @@ public override bool Walk(ReturnStatement node) { var value = Eval.GetValueFromExpression(node.Expression); if (value != null) { // although technically legal, __init__ in a constructor should not have a not-none return value - if (FunctionDefinition.Name.EqualsOrdinal("__init__") && _function.DeclaringType.MemberType == PythonMemberType.Class - && !value.IsOfType(BuiltinTypeId.NoneType)) { + if (FunctionDefinition.Name.EqualsOrdinal("__init__") && _function.DeclaringType.MemberType == PythonMemberType.Class + && !value.IsOfType(BuiltinTypeId.NoneType)) { Eval.ReportDiagnostics(Module.Uri, new Diagnostics.DiagnosticsEntry( Resources.ReturnInInit, diff --git a/src/Analysis/Ast/Impl/Analyzer/Symbols/SymbolCollector.cs b/src/Analysis/Ast/Impl/Analyzer/Symbols/SymbolCollector.cs index a3f489cf7..cf49cc3ee 100644 --- a/src/Analysis/Ast/Impl/Analyzer/Symbols/SymbolCollector.cs +++ b/src/Analysis/Ast/Impl/Analyzer/Symbols/SymbolCollector.cs @@ -15,12 +15,13 @@ using System; using System.Collections.Generic; +using System.Diagnostics; using System.Linq; using Microsoft.Python.Analysis.Analyzer.Evaluation; -using Microsoft.Python.Analysis.Diagnostics; using Microsoft.Python.Analysis.Types; using Microsoft.Python.Analysis.Values; using Microsoft.Python.Core; +using Microsoft.Python.Core.OS; using Microsoft.Python.Parsing.Ast; namespace Microsoft.Python.Analysis.Analyzer.Symbols { @@ -29,7 +30,7 @@ namespace Microsoft.Python.Analysis.Analyzer.Symbols { /// so the symbol table can resolve references on demand. /// internal sealed class SymbolCollector : PythonWalker { - private readonly Dictionary _typeMap = new Dictionary(); + private readonly Dictionary _typeMap = new Dictionary(); private readonly Stack _scopes = new Stack(); private readonly ModuleSymbolTable _table; private readonly ExpressionEval _eval; @@ -46,6 +47,9 @@ private SymbolCollector(ModuleSymbolTable table, ExpressionEval eval) { private void Walk() => _eval.Ast.Walk(this); + public override bool Walk(IfStatement node) + => node.WalkIfWithSystemConditions(this, _eval.Ast.LanguageVersion, _eval.Services.GetService().IsWindows); + public override bool Walk(ClassDefinition cd) { if (IsDeprecated(cd)) { return false; @@ -90,9 +94,16 @@ public override void PostWalk(FunctionDefinition fd) { } private PythonClassType CreateClass(ClassDefinition cd) { - var cls = new PythonClassType(cd, _eval.GetLocationOfName(cd), + PythonType declaringType = null; + if(!(cd.Parent is PythonAst)) { + Debug.Assert(_typeMap.ContainsKey(cd.Parent)); + _typeMap.TryGetValue(cd.Parent, out declaringType); + } + var cls = new PythonClassType(cd, declaringType, _eval.GetLocationOfName(cd), _eval.SuppressBuiltinLookup ? BuiltinTypeId.Unknown : BuiltinTypeId.Type); _typeMap[cd] = cls; + + declaringType?.AddMember(cls.Name, cls, overwrite: true); return cls; } @@ -104,14 +115,16 @@ private void AddFunctionOrProperty(FunctionDefinition fd) { } } - private void AddFunction(FunctionDefinition fd, IPythonType declaringType) { - if (!(_eval.LookupNameInScopes(fd.Name, LookupOptions.Local) is PythonFunctionType existing)) { - existing = new PythonFunctionType(fd, declaringType, _eval.GetLocationOfName(fd)); + private void AddFunction(FunctionDefinition fd, PythonType declaringType) { + if (!(_eval.LookupNameInScopes(fd.Name, LookupOptions.Local) is PythonFunctionType f)) { + f = new PythonFunctionType(fd, declaringType, _eval.GetLocationOfName(fd)); // The variable is transient (non-user declared) hence it does not have location. // Function type is tracking locations for references and renaming. - _eval.DeclareVariable(fd.Name, existing, VariableSource.Declaration); + _eval.DeclareVariable(fd.Name, f, VariableSource.Declaration); + _typeMap[fd] = f; + declaringType?.AddMember(f.Name, f, overwrite: true); } - AddOverload(fd, existing, o => existing.AddOverload(o)); + AddOverload(fd, f, o => f.AddOverload(o)); } private void AddOverload(FunctionDefinition fd, IPythonClassMember function, Action addOverload) { @@ -149,7 +162,7 @@ private PythonFunctionOverload GetOverloadFromStub(FunctionDefinition node) { return null; } - private bool TryAddProperty(FunctionDefinition node, IPythonType declaringType) { + private bool TryAddProperty(FunctionDefinition node, PythonType declaringType) { var dec = node.Decorators?.Decorators; var decorators = dec != null ? dec.ExcludeDefault().ToArray() : Array.Empty(); @@ -166,14 +179,16 @@ private bool TryAddProperty(FunctionDefinition node, IPythonType declaringType) return false; } - private void AddProperty(FunctionDefinition fd, IPythonType declaringType, bool isAbstract) { - if (!(_eval.LookupNameInScopes(fd.Name, LookupOptions.Local) is PythonPropertyType existing)) { - existing = new PythonPropertyType(fd, _eval.GetLocationOfName(fd), declaringType, isAbstract); + private void AddProperty(FunctionDefinition fd, PythonType declaringType, bool isAbstract) { + if (!(_eval.LookupNameInScopes(fd.Name, LookupOptions.Local) is PythonPropertyType p)) { + p = new PythonPropertyType(fd, _eval.GetLocationOfName(fd), declaringType, isAbstract); // The variable is transient (non-user declared) hence it does not have location. // Property type is tracking locations for references and renaming. - _eval.DeclareVariable(fd.Name, existing, VariableSource.Declaration); + _eval.DeclareVariable(fd.Name, p, VariableSource.Declaration); + _typeMap[fd] = p; + declaringType?.AddMember(p.Name, p, overwrite: true); } - AddOverload(fd, existing, o => existing.AddOverload(o)); + AddOverload(fd, p, o => p.AddOverload(o)); } private IMember GetMemberFromStub(string name) { diff --git a/src/Analysis/Ast/Impl/Documents/Definitions/IRunningDocumentTable.cs b/src/Analysis/Ast/Impl/Documents/Definitions/IRunningDocumentTable.cs index 442327bd8..b1e9dcaef 100644 --- a/src/Analysis/Ast/Impl/Documents/Definitions/IRunningDocumentTable.cs +++ b/src/Analysis/Ast/Impl/Documents/Definitions/IRunningDocumentTable.cs @@ -90,5 +90,10 @@ public interface IRunningDocumentTable { /// Fires when document is removed. /// event EventHandler Removed; + + /// + /// Gets the number of documents in the table. + /// + int DocumentCount { get; } } } diff --git a/src/Analysis/Ast/Impl/Documents/RunningDocumentTable.cs b/src/Analysis/Ast/Impl/Documents/RunningDocumentTable.cs index cb99f182d..34e017efc 100644 --- a/src/Analysis/Ast/Impl/Documents/RunningDocumentTable.cs +++ b/src/Analysis/Ast/Impl/Documents/RunningDocumentTable.cs @@ -69,6 +69,14 @@ public IEnumerable GetDocuments() { } } + public int DocumentCount { + get { + lock (_lock) { + return _documentsByUri.Count; + } + } + } + /// /// Adds file to the list of available documents. /// diff --git a/src/Analysis/Ast/Impl/Extensions/ArgumentSetExtensions.cs b/src/Analysis/Ast/Impl/Extensions/ArgumentSetExtensions.cs index 56b3d745a..ef999a511 100644 --- a/src/Analysis/Ast/Impl/Extensions/ArgumentSetExtensions.cs +++ b/src/Analysis/Ast/Impl/Extensions/ArgumentSetExtensions.cs @@ -64,7 +64,7 @@ internal static void DeclareParametersInScope(this IArgumentSet args, Expression } if (args.ListArgument != null && !string.IsNullOrEmpty(args.ListArgument.Name)) { - var type = new PythonCollectionType(null, BuiltinTypeId.List, eval.BuiltinsModule, false); + var type = new PythonCollectionType(BuiltinTypeId.List, eval.BuiltinsModule, false); var list = new PythonCollection(type, args.ListArgument.Values); eval.DeclareVariable(args.ListArgument.Name, list, VariableSource.Declaration, args.ListArgument.Location); } diff --git a/src/Analysis/Ast/Impl/Extensions/IfStatementExtensions.cs b/src/Analysis/Ast/Impl/Extensions/IfStatementExtensions.cs new file mode 100644 index 000000000..43a8e6869 --- /dev/null +++ b/src/Analysis/Ast/Impl/Extensions/IfStatementExtensions.cs @@ -0,0 +1,94 @@ +// Copyright(c) Microsoft Corporation +// All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the License); you may not use +// this file except in compliance with the License. You may obtain a copy of the +// License at http://www.apache.org/licenses/LICENSE-2.0 +// +// THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS +// OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY +// IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +// MERCHANTABILITY OR NON-INFRINGEMENT. +// +// See the Apache Version 2.0 License for specific language governing +// permissions and limitations under the License. + +using System; +using System.Linq; +using Microsoft.Python.Parsing; +using Microsoft.Python.Parsing.Ast; + +namespace Microsoft.Python.Analysis { + public enum ConditionTestResult { + Unrecognized, + DontWalkBody, + WalkBody + } + + public static class IfStatementExtensions { + public static ConditionTestResult TryHandleSysVersionInfo(this IfStatementTest test, PythonLanguageVersion languageVersion) { + if (test.Test is BinaryExpression cmp && + cmp.Left is MemberExpression me && (me.Target as NameExpression)?.Name == "sys" && me.Name == "version_info" && + cmp.Right is TupleExpression te && te.Items.All(i => (i as ConstantExpression)?.Value is int)) { + Version v; + try { + v = new Version( + (int)((te.Items.ElementAtOrDefault(0) as ConstantExpression)?.Value ?? 0), + (int)((te.Items.ElementAtOrDefault(1) as ConstantExpression)?.Value ?? 0) + ); + } catch (ArgumentException) { + // Unsupported comparison, so walk all children + return ConditionTestResult.WalkBody; + } + + var shouldWalk = false; + switch (cmp.Operator) { + case PythonOperator.LessThan: + shouldWalk = languageVersion.ToVersion() < v; + break; + case PythonOperator.LessThanOrEqual: + shouldWalk = languageVersion.ToVersion() <= v; + break; + case PythonOperator.GreaterThan: + shouldWalk = languageVersion.ToVersion() > v; + break; + case PythonOperator.GreaterThanOrEqual: + shouldWalk = languageVersion.ToVersion() >= v; + break; + } + return shouldWalk ? ConditionTestResult.WalkBody : ConditionTestResult.DontWalkBody; + } + return ConditionTestResult.Unrecognized; + } + + public static ConditionTestResult TryHandleSysPlatform(this IfStatementTest test, bool isWindows) { + if (test.Test is BinaryExpression cmp && + cmp.Left is MemberExpression me && (me.Target as NameExpression)?.Name == "sys" && me.Name == "platform" && + cmp.Right is ConstantExpression cex && cex.GetStringValue() is string s) { + switch (cmp.Operator) { + case PythonOperator.Equals: + return s == "win32" && isWindows ? ConditionTestResult.WalkBody : ConditionTestResult.DontWalkBody; + case PythonOperator.NotEquals: + return s == "win32" && isWindows ? ConditionTestResult.DontWalkBody : ConditionTestResult.WalkBody; + } + return ConditionTestResult.DontWalkBody; + } + return ConditionTestResult.Unrecognized; + } + + public static ConditionTestResult TryHandleOsPath(this IfStatementTest test, bool isWindows) { + if (test.Test is BinaryExpression cmp && + cmp.Left is ConstantExpression cex && cex.GetStringValue() is string s && + cmp.Right is NameExpression nex && nex.Name == "_names") { + switch (cmp.Operator) { + case PythonOperator.In when s == "nt": + return isWindows ? ConditionTestResult.WalkBody : ConditionTestResult.DontWalkBody; + case PythonOperator.In when s == "posix": + return isWindows ? ConditionTestResult.DontWalkBody : ConditionTestResult.WalkBody; + } + return ConditionTestResult.DontWalkBody; + } + return ConditionTestResult.Unrecognized; + } + } +} diff --git a/src/Analysis/Ast/Impl/Extensions/PythonFunctionExtensions.cs b/src/Analysis/Ast/Impl/Extensions/PythonFunctionExtensions.cs index a53be479c..4c6ec4e7f 100644 --- a/src/Analysis/Ast/Impl/Extensions/PythonFunctionExtensions.cs +++ b/src/Analysis/Ast/Impl/Extensions/PythonFunctionExtensions.cs @@ -15,18 +15,21 @@ using System.Collections.Generic; using System.Linq; +using Microsoft.Python.Analysis.Modules; using Microsoft.Python.Analysis.Types; using Microsoft.Python.Analysis.Values; using Microsoft.Python.Core; namespace Microsoft.Python.Analysis { public static class PythonFunctionExtensions { - public static bool IsUnbound(this IPythonFunctionType f) + public static bool IsUnbound(this IPythonFunctionType f) => f.DeclaringType != null && f.MemberType == PythonMemberType.Function; - public static bool IsBound(this IPythonFunctionType f) + public static bool IsBound(this IPythonFunctionType f) => f.DeclaringType != null && f.MemberType == PythonMemberType.Method; + public static bool IsLambda(this IPythonFunctionType f) => f.Name == ""; + public static bool HasClassFirstArgument(this IPythonClassMember m) => (m is IPythonFunctionType f && !f.IsStatic && (f.IsClassMethod || f.IsBound())) || (m is IPythonPropertyType prop); @@ -42,7 +45,9 @@ public static string GetQualifiedName(this IPythonClassMember cm) { for (var p = cm.DeclaringType as IPythonClassMember; p != null; p = p.DeclaringType as IPythonClassMember) { s.Push(p.Name); } - return $"{cm.DeclaringModule.Name}:{string.Join(".", s)}"; + return cm.DeclaringModule.ModuleType == ModuleType.Builtins + ? string.Join(".", s) + : $"{cm.DeclaringModule.Name}:{string.Join(".", s)}"; } } } diff --git a/src/Analysis/Ast/Impl/Extensions/PythonTypeExtensions.cs b/src/Analysis/Ast/Impl/Extensions/PythonTypeExtensions.cs index 1e87eb99a..2e948660b 100644 --- a/src/Analysis/Ast/Impl/Extensions/PythonTypeExtensions.cs +++ b/src/Analysis/Ast/Impl/Extensions/PythonTypeExtensions.cs @@ -13,7 +13,6 @@ // See the Apache Version 2.0 License for specific language governing // permissions and limitations under the License. -using System.Diagnostics; using Microsoft.Python.Analysis.Specializations.Typing; using Microsoft.Python.Analysis.Types; using Microsoft.Python.Core; @@ -29,20 +28,12 @@ public static bool IsGenericParameter(this IPythonType value) public static bool IsGeneric(this IPythonType value) => value is IGenericTypeDefinition || value is IGenericType || (value is IPythonClassType c && c.IsGeneric()); - public static void TransferDocumentationAndLocation(this IPythonType s, IPythonType d) { - if (s != d && s is PythonType src && d is PythonType dst) { - var documentation = src.Documentation; - if (!string.IsNullOrEmpty(documentation)) { - dst.SetDocumentation(documentation); - } - - dst.Location = src.Location; - } - } - public static bool IsConstructor(this IPythonClassMember m) => m.Name.EqualsOrdinal("__init__") || m.Name.EqualsOrdinal("__new__"); public static string GetQualifiedName(this IPythonType t) => $"{t.DeclaringModule.Name}:{t.Name}"; + + internal static IPythonType ToBound(this IPythonType t) => t is PythonFunctionType.PythonUnboundMethod m ? m.Function : t; + } } diff --git a/src/Analysis/Ast/Impl/Extensions/PythonWalkerExtensions.cs b/src/Analysis/Ast/Impl/Extensions/PythonWalkerExtensions.cs new file mode 100644 index 000000000..affefbf2d --- /dev/null +++ b/src/Analysis/Ast/Impl/Extensions/PythonWalkerExtensions.cs @@ -0,0 +1,61 @@ +// Copyright(c) Microsoft Corporation +// All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the License); you may not use +// this file except in compliance with the License. You may obtain a copy of the +// License at http://www.apache.org/licenses/LICENSE-2.0 +// +// THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS +// OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY +// IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +// MERCHANTABILITY OR NON-INFRINGEMENT. +// +// See the Apache Version 2.0 License for specific language governing +// permissions and limitations under the License. + +using Microsoft.Python.Parsing; +using Microsoft.Python.Parsing.Ast; + +namespace Microsoft.Python.Analysis { + public static class PythonWalkerExtensions { + public static bool WalkIfWithSystemConditions(this IfStatement node, PythonWalker walker, PythonLanguageVersion languageVersion, bool isWindows) { + // System version, platform and os.path specializations + var executeElse = false; + foreach (var test in node.Tests) { + + var result = test.TryHandleSysVersionInfo(languageVersion); + if (result == ConditionTestResult.Unrecognized) { + result = test.TryHandleSysPlatform(isWindows); + if (result == ConditionTestResult.Unrecognized) { + result = test.TryHandleOsPath(isWindows); + } + } + + // If condition is satisfied, walk the corresponding block and + // return false indicating that statement should not be walked again. + // If condition is false or was not recognized, continue but remember + // if we need to execute final else clause. + switch (result) { + case ConditionTestResult.WalkBody: + test.Walk(walker); + return false; // We only need to execute one of the clauses. + case ConditionTestResult.DontWalkBody: + // If condition is false, continue but remember + // if we may need to execute the final else clause. + executeElse = true; + break; + case ConditionTestResult.Unrecognized: + continue; // See if other conditions may work. + } + } + + if (executeElse) { + node.ElseStatement?.Walk(walker); + return false; + } + + // We didn't walk anything, so me caller do their own thing. + return true; + } + } +} diff --git a/src/Analysis/Ast/Impl/Microsoft.Python.Analysis.csproj b/src/Analysis/Ast/Impl/Microsoft.Python.Analysis.csproj index 8f4bbee5a..7d7bacfec 100644 --- a/src/Analysis/Ast/Impl/Microsoft.Python.Analysis.csproj +++ b/src/Analysis/Ast/Impl/Microsoft.Python.Analysis.csproj @@ -38,6 +38,7 @@ + diff --git a/src/Analysis/Ast/Impl/Modules/Definitions/IModuleManagement.cs b/src/Analysis/Ast/Impl/Modules/Definitions/IModuleManagement.cs index 84833d141..703d8be8c 100644 --- a/src/Analysis/Ast/Impl/Modules/Definitions/IModuleManagement.cs +++ b/src/Analysis/Ast/Impl/Modules/Definitions/IModuleManagement.cs @@ -14,9 +14,7 @@ // permissions and limitations under the License. using System; -using System.Collections; using System.Collections.Generic; -using System.Threading; using Microsoft.Python.Analysis.Caching; using Microsoft.Python.Analysis.Core.Interpreter; using Microsoft.Python.Analysis.Types; @@ -33,8 +31,6 @@ public interface IModuleManagement: IModuleResolution { /// ModulePath FindModule(string filePath); - IReadOnlyCollection GetPackagesFromDirectory(string searchPath, CancellationToken cancellationToken = default); - /// /// Cache of module stubs generated from compiled modules. /// @@ -50,8 +46,9 @@ public interface IModuleManagement: IModuleResolution { /// /// Module to specialize. /// Specialized module constructor. - /// Original (library) module loaded as stub, if any. - IPythonModule SpecializeModule(string fullName, Func specializationConstructor); + /// Replace existing loaded module, if any. + /// Specialized module. + IPythonModule SpecializeModule(string fullName, Func specializationConstructor, bool replaceExisting = false); /// /// Returns specialized module, if any. Will attempt to load module from persistent state. @@ -72,5 +69,10 @@ public interface IModuleManagement: IModuleResolution { /// Set of interpreter paths. /// IEnumerable InterpreterPaths { get; } + + /// + /// Interpreter paths with additional classification. + /// + IReadOnlyList LibraryPaths { get; } } } diff --git a/src/Analysis/Ast/Impl/Modules/Definitions/ModuleCreationOptions.cs b/src/Analysis/Ast/Impl/Modules/Definitions/ModuleCreationOptions.cs index b49e555dc..f9c1dc9aa 100644 --- a/src/Analysis/Ast/Impl/Modules/Definitions/ModuleCreationOptions.cs +++ b/src/Analysis/Ast/Impl/Modules/Definitions/ModuleCreationOptions.cs @@ -14,6 +14,7 @@ // permissions and limitations under the License. using System; +using Microsoft.Python.Analysis.Core.Interpreter; using Microsoft.Python.Analysis.Types; namespace Microsoft.Python.Analysis.Modules { diff --git a/src/Analysis/Ast/Impl/Modules/PythonModule.cs b/src/Analysis/Ast/Impl/Modules/PythonModule.cs index cc1980873..c9c0b4576 100644 --- a/src/Analysis/Ast/Impl/Modules/PythonModule.cs +++ b/src/Analysis/Ast/Impl/Modules/PythonModule.cs @@ -22,6 +22,7 @@ using System.Threading; using System.Threading.Tasks; using Microsoft.Python.Analysis.Analyzer; +using Microsoft.Python.Analysis.Core.Interpreter; using Microsoft.Python.Analysis.Diagnostics; using Microsoft.Python.Analysis.Documents; using Microsoft.Python.Analysis.Specializations.Typing; @@ -103,8 +104,10 @@ internal PythonModule(ModuleCreationOptions creationOptions, IServiceContainer s if (uri == null && !string.IsNullOrEmpty(creationOptions.FilePath)) { Uri.TryCreate(creationOptions.FilePath, UriKind.Absolute, out uri); } + Uri = uri; FilePath = creationOptions.FilePath ?? uri?.LocalPath; + Stub = creationOptions.Stub; if (Stub is PythonModule stub && ModuleType != ModuleType.Stub) { stub.PrimaryModule = this; @@ -113,6 +116,7 @@ internal PythonModule(ModuleCreationOptions creationOptions, IServiceContainer s if (ModuleType == ModuleType.Specialized || ModuleType == ModuleType.Unresolved) { ContentState = State.Analyzed; } + InitializeContent(creationOptions.Content, 0); } @@ -164,8 +168,20 @@ public virtual IEnumerable GetMemberNames() { if (valueType is PythonModule) { return false; // Do not re-export modules. } - // Do not re-export types from typing - return !(valueType?.DeclaringModule is TypingModule) || this is TypingModule; + if(valueType is IPythonFunctionType f && f.IsLambda()) { + return false; + } + if (this is TypingModule) { + return true; // Let typing module behave normally. + } + // Do not re-export types from typing. However, do export variables + // assigned with types from typing. Example: + // from typing import Any # do NOT export Any + // x = Union[int, str] # DO export x + if(valueType?.DeclaringModule is TypingModule && v.Name == valueType.Name) { + return false; + } + return true; }) .Select(v => v.Name); } diff --git a/src/Analysis/Ast/Impl/Modules/PythonVariableModule.cs b/src/Analysis/Ast/Impl/Modules/PythonVariableModule.cs index 74efc4f56..e28964258 100644 --- a/src/Analysis/Ast/Impl/Modules/PythonVariableModule.cs +++ b/src/Analysis/Ast/Impl/Modules/PythonVariableModule.cs @@ -16,6 +16,9 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using Microsoft.Python.Analysis.Core.Interpreter; using Microsoft.Python.Analysis.Types; using Microsoft.Python.Analysis.Values; using Microsoft.Python.Core; diff --git a/src/Analysis/Ast/Impl/Modules/Resolution/MainModuleResolution.cs b/src/Analysis/Ast/Impl/Modules/Resolution/MainModuleResolution.cs index d5a500c3f..f428b6774 100644 --- a/src/Analysis/Ast/Impl/Modules/Resolution/MainModuleResolution.cs +++ b/src/Analysis/Ast/Impl/Modules/Resolution/MainModuleResolution.cs @@ -44,6 +44,8 @@ internal sealed class MainModuleResolution : ModuleResolutionBase, IModuleManage public MainModuleResolution(string root, IServiceContainer services) : base(root, services) { } + public IReadOnlyList LibraryPaths { get; private set; } = Array.Empty(); + internal IBuiltinsPythonModule CreateBuiltinsModule() { if (BuiltinsModule == null) { // Initialize built-in @@ -150,25 +152,37 @@ private async Task> GetInterpreterSearchPathsAs /// /// Module to specialize. /// Specialized module constructor. - /// Original (library) module loaded as stub. - public IPythonModule SpecializeModule(string name, Func specializationConstructor) { + /// Replace existing loaded module, if any. + /// Specialized module. + public IPythonModule SpecializeModule(string name, Func specializationConstructor, bool replaceExisting = false) { var import = CurrentPathResolver.GetModuleImportFromModuleName(name); var module = specializationConstructor(import?.ModulePath); _specialized[name] = module; + + if (replaceExisting) { + Modules.TryRemove(name, out _); + } return module; } /// /// Returns specialized module, if any. /// - public IPythonModule GetSpecializedModule(string fullName, bool allowCreation = false, string modulePath = null) + public IPythonModule GetSpecializedModule(string fullName, bool allowCreation = false, string modulePath = null) => _specialized.TryGetValue(fullName, out var module) ? module : null; /// /// Determines of module is specialized or exists in the database. /// - public bool IsSpecializedModule(string fullName, string modulePath = null) - => _specialized.ContainsKey(fullName) || GetDbService()?.ModuleExistsInStorage(fullName, modulePath) == true; + public bool IsSpecializedModule(string fullName, string modulePath = null) { + if (_specialized.ContainsKey(fullName)) { + return true; + } + if (modulePath != null && Path.GetExtension(modulePath) == ".pyi") { + return false; + } + return GetDbService()?.ModuleExistsInStorage(fullName, modulePath) == true; + } internal async Task LoadBuiltinTypesAsync(CancellationToken cancellationToken = default) { var analyzer = _services.GetService(); @@ -186,10 +200,8 @@ internal async Task LoadBuiltinTypesAsync(CancellationToken cancellationToken = } internal async Task ReloadSearchPaths(CancellationToken cancellationToken = default) { - var ps = _services.GetService(); - - var paths = await GetInterpreterSearchPathsAsync(cancellationToken); - var (interpreterPaths, userPaths) = PythonLibraryPath.ClassifyPaths(Root, _fs, paths, Configuration.SearchPaths); + LibraryPaths = await GetInterpreterSearchPathsAsync(cancellationToken); + var (interpreterPaths, userPaths) = PythonLibraryPath.ClassifyPaths(Root, _fs, LibraryPaths, Configuration.SearchPaths); InterpreterPaths = interpreterPaths.Select(p => p.Path); _userPaths = userPaths.Select(p => p.Path); diff --git a/src/Analysis/Ast/Impl/Modules/Resolution/ModuleResolutionBase.cs b/src/Analysis/Ast/Impl/Modules/Resolution/ModuleResolutionBase.cs index a9e699d11..a9060889f 100644 --- a/src/Analysis/Ast/Impl/Modules/Resolution/ModuleResolutionBase.cs +++ b/src/Analysis/Ast/Impl/Modules/Resolution/ModuleResolutionBase.cs @@ -56,7 +56,6 @@ protected ModuleResolutionBase(string root, IServiceContainer services) { public string Root { get; protected set; } public IEnumerable InterpreterPaths { get; protected set; } = Enumerable.Empty(); - public IModuleCache ModuleCache { get; protected set; } public string BuiltinModuleName => BuiltinTypeId.Unknown.GetModuleName(_interpreter.LanguageVersion); /// diff --git a/src/Analysis/Ast/Impl/Specializations/BuiltinsSpecializations.cs b/src/Analysis/Ast/Impl/Specializations/BuiltinsSpecializations.cs index 3b98a971e..7815fe4a8 100644 --- a/src/Analysis/Ast/Impl/Specializations/BuiltinsSpecializations.cs +++ b/src/Analysis/Ast/Impl/Specializations/BuiltinsSpecializations.cs @@ -30,7 +30,8 @@ public static IMember Identity(IPythonModule module, IPythonFunctionOverload ove public static IMember TypeInfo(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet) { var args = argSet.Values(); - return args.Count > 0 ? args[0].GetPythonType() : module.Interpreter.GetBuiltinType(BuiltinTypeId.Type); + var t = args.Count > 0 ? args[0].GetPythonType() : module.Interpreter.GetBuiltinType(BuiltinTypeId.Type); + return t.ToBound(); } public static IMember Iterator(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet) { @@ -78,7 +79,7 @@ public static IMember __iter__(IPythonInterpreter interpreter, BuiltinTypeId con public static IMember Range(IPythonModule module, IPythonFunctionOverload overload, IArgumentSet argSet) { var args = argSet.Values(); if (args.Count > 0) { - var type = new PythonCollectionType(null, BuiltinTypeId.List, module.Interpreter.ModuleResolution.BuiltinsModule, false); + var type = new PythonCollectionType(BuiltinTypeId.List, module.Interpreter.ModuleResolution.BuiltinsModule, false); return new PythonCollection(type, new[] { args[0] }); } return null; diff --git a/src/Analysis/Ast/Impl/Specializations/Typing/Types/AnyType.cs b/src/Analysis/Ast/Impl/Specializations/Typing/Types/AnyType.cs index 25b1eb39d..73eef02f4 100644 --- a/src/Analysis/Ast/Impl/Specializations/Typing/Types/AnyType.cs +++ b/src/Analysis/Ast/Impl/Specializations/Typing/Types/AnyType.cs @@ -24,7 +24,7 @@ public AnyType(IPythonModule declaringModule) : base(declaringModule) { } public override PythonMemberType MemberType => PythonMemberType.Class; public string Name => "Any"; - public string QualifiedName => this.GetQualifiedName(); + public string QualifiedName => "typing:Any"; public BuiltinTypeId TypeId => BuiltinTypeId.Type; public string Documentation => Name; public bool IsBuiltin => false; diff --git a/src/Analysis/Ast/Impl/Specializations/Typing/Types/GenericType.cs b/src/Analysis/Ast/Impl/Specializations/Typing/Types/GenericType.cs index 6c2bfea26..b86688150 100644 --- a/src/Analysis/Ast/Impl/Specializations/Typing/Types/GenericType.cs +++ b/src/Analysis/Ast/Impl/Specializations/Typing/Types/GenericType.cs @@ -14,6 +14,7 @@ // permissions and limitations under the License. using System; +using System.Collections; using System.Collections.Generic; using System.Linq; using Microsoft.Python.Analysis.Types; @@ -32,7 +33,7 @@ internal class GenericType : LocatedMember, IGenericType { /// Constructs generic type with generic type parameters. Typically used /// in generic classes such as when handling Generic[_T] base. /// - public GenericType(string name, IReadOnlyList parameters, IPythonModule declaringModule) + public GenericType(string name, IReadOnlyList parameters, IPythonModule declaringModule) : this(name, declaringModule) { Parameters = parameters ?? throw new ArgumentNullException(nameof(parameters)); } @@ -90,7 +91,7 @@ public IPythonType CreateSpecificType(IReadOnlyList typeArguments) public bool IsSpecialized => true; public IMember CreateInstance(string typeName, IArgumentSet args) { - var types = args.Values(); + var types = GetTypesFromValues(args.Arguments); if (types.Count != args.Arguments.Count) { throw new ArgumentException(@"Generic type instance construction arguments must be all of IPythonType", nameof(args)); } @@ -104,7 +105,7 @@ public IMember CreateInstance(string typeName, IArgumentSet args) { public virtual IMember Index(IPythonInstance instance, IArgumentSet args) => DeclaringModule.Interpreter.UnknownType; public IPythonType CreateSpecificType(IArgumentSet typeArguments) - => CreateSpecificType(typeArguments.Arguments.Select(a => a.Value).OfType().ToArray()); + => CreateSpecificType(GetTypesFromValues(typeArguments.Arguments)); #endregion public override bool Equals(object other) { @@ -119,5 +120,8 @@ public override bool Equals(object other) { public override int GetHashCode() => TypeId != BuiltinTypeId.Unknown ? TypeId.GetHashCode() : base.GetHashCode(); + + private IReadOnlyList GetTypesFromValues(IEnumerable args) + => args.Select(a => a.Value).OfType().Select(m => m.GetPythonType()).ToArray(); } } diff --git a/src/Analysis/Ast/Impl/Specializations/Typing/Types/NamedTupleType.cs b/src/Analysis/Ast/Impl/Specializations/Typing/Types/NamedTupleType.cs index 2343bec6b..cfad82980 100644 --- a/src/Analysis/Ast/Impl/Specializations/Typing/Types/NamedTupleType.cs +++ b/src/Analysis/Ast/Impl/Specializations/Typing/Types/NamedTupleType.cs @@ -27,20 +27,25 @@ internal sealed class NamedTupleType : TypingTupleType, ITypingNamedTupleType { /// /// Creates type info for a strongly-typed tuple, such as Tuple[T1, T2, ...]. /// - public NamedTupleType(string tupleName, IReadOnlyList itemNames, IReadOnlyList itemTypes, IPythonInterpreter interpreter) - : base(itemTypes, interpreter) { + public NamedTupleType(string tupleName, IReadOnlyList itemNames, IReadOnlyList itemTypes, IPythonModule declaringModule, IPythonInterpreter interpreter) + : base(itemTypes, declaringModule, interpreter) { TupleName = tupleName ?? throw new ArgumentNullException(nameof(tupleName)); ItemNames = itemNames; var typeNames = itemTypes.Select(t => t.IsUnknown() ? string.Empty : t.Name); var pairs = itemNames.Zip(typeNames, (name, typeName) => string.IsNullOrEmpty(typeName) ? name : $"{name}: {typeName}"); Name = CodeFormatter.FormatSequence(tupleName, '(', pairs); + + typeNames = itemTypes.Select(t => t.IsUnknown() ? string.Empty : t.QualifiedName); + pairs = itemNames.Zip(typeNames, (name, typeName) => string.IsNullOrEmpty(typeName) ? name : $"{name}: {typeName}"); + QualifiedName = CodeFormatter.FormatSequence($"{declaringModule.Name}:{tupleName}", '(', pairs); } public string TupleName { get; } public IReadOnlyList ItemNames { get; } public override string Name { get; } + public override string QualifiedName { get; } public override bool IsSpecialized => true; public override IMember CreateInstance(string typeName, IArgumentSet args) => new TypingTuple(this); diff --git a/src/Analysis/Ast/Impl/Specializations/Typing/Types/OptionalType.cs b/src/Analysis/Ast/Impl/Specializations/Typing/Types/OptionalType.cs index a4ba593a8..0c89c3a7a 100644 --- a/src/Analysis/Ast/Impl/Specializations/Typing/Types/OptionalType.cs +++ b/src/Analysis/Ast/Impl/Specializations/Typing/Types/OptionalType.cs @@ -22,8 +22,10 @@ namespace Microsoft.Python.Analysis.Specializations.Typing.Types { internal sealed class OptionalType : PythonTypeWrapper, IPythonUnionType { public OptionalType(IPythonModule declaringModule, IPythonType type) : base(type, declaringModule) { Name = $"Optional[{type.Name}]"; + QualifiedName = $"typing:Optional[{type.QualifiedName}]"; } public override string Name { get; } + public override string QualifiedName { get; } public override PythonMemberType MemberType => PythonMemberType.Union; public override bool IsSpecialized => true; diff --git a/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypeAlias.cs b/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypeAlias.cs index ffcbde6a1..67d93be1c 100644 --- a/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypeAlias.cs +++ b/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypeAlias.cs @@ -21,6 +21,7 @@ public TypeAlias(string name, IPythonType type) : base(type) { Name = name; } public override string Name { get; } + public override string QualifiedName => $"typing:{Name}"; public override bool IsSpecialized => true; } diff --git a/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingDictionaryType.cs b/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingDictionaryType.cs index 23f84f589..6f0e55bd4 100644 --- a/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingDictionaryType.cs +++ b/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingDictionaryType.cs @@ -38,6 +38,7 @@ public TypingDictionaryType(string name, IPythonType keyType, IPythonType valueT KeyType = keyType; ValueType = valueType; Name = $"{name}[{keyType.Name}, {valueType.Name}]"; + QualifiedName = $"typing:{name}[{keyType.QualifiedName}, {valueType.QualifiedName}]"; } public IPythonType KeyType { get; } @@ -45,13 +46,14 @@ public TypingDictionaryType(string name, IPythonType keyType, IPythonType valueT public IPythonType ItemType => _itemType ?? (_itemType = CreateItemType()); public override string Name { get; } + public override string QualifiedName { get; } public override IMember CreateInstance(string typeName, IArgumentSet args) => new TypingDictionary(this); public override IMember Index(IPythonInstance instance, IArgumentSet args) => new PythonInstance(ValueType); public override bool IsSpecialized => true; private TypingTupleType CreateItemType() { - var itemType = new TypingTupleType(new[] { KeyType, ValueType }, DeclaringModule.Interpreter); + var itemType = new TypingTupleType(new[] { KeyType, ValueType }, DeclaringModule, DeclaringModule.Interpreter); return itemType; } diff --git a/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingIteratorType.cs b/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingIteratorType.cs index fa721e862..1b4fa245f 100644 --- a/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingIteratorType.cs +++ b/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingIteratorType.cs @@ -34,6 +34,7 @@ public TypingIteratorType(IPythonType itemType, BuiltinTypeId iteratorType, IPyt ItemTypes = new[] { itemType }; Repeat = true; Name = $"Iterator[{itemType.Name}]"; + QualifiedName = $"typing:Iterator[{itemType.QualifiedName}]"; } /// @@ -44,11 +45,13 @@ public TypingIteratorType(IReadOnlyList itemTypes, BuiltinTypeId it : base(iteratorType, interpreter.ModuleResolution.GetSpecializedModule("typing")) { ItemTypes = itemTypes; Name = $"Iterator[{CodeFormatter.FormatSequence(string.Empty, '(', itemTypes)}]"; + QualifiedName = $"typing:Iterator[{CodeFormatter.FormatSequence(string.Empty, '(', itemTypes.Select(t => t.QualifiedName))}]"; } public IReadOnlyList ItemTypes { get; } public bool Repeat { get; } public override string Name { get; } + public override string QualifiedName { get; } public override bool IsSpecialized => true; diff --git a/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingListType.cs b/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingListType.cs index 778e2d6ec..2c1d3ba27 100644 --- a/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingListType.cs +++ b/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingListType.cs @@ -41,12 +41,14 @@ public TypingListType(string typeName, IPythonType itemType, IPythonInterpreter /// Tells of list represents a mutable collection. /// If true, type will append item type names to the base type name. public TypingListType(string typeName, BuiltinTypeId typeId, IPythonType itemType, IPythonInterpreter interpreter, bool isMutable, bool formatName = true) - : base(null, typeId, interpreter.ModuleResolution.GetSpecializedModule("typing"), isMutable) { + : base(typeId, interpreter.ModuleResolution.GetSpecializedModule("typing"), isMutable) { ItemType = itemType; Name = formatName ? $"{typeName}[{itemType.Name}]" : typeName; + QualifiedName = formatName ? $"typing:{typeName}[{itemType.QualifiedName}]" : $"typing:{typeName}"; } public override string Name { get; } + public override string QualifiedName { get; } public override bool IsAbstract => false; public override bool IsSpecialized => true; diff --git a/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingTupleType.cs b/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingTupleType.cs index 690c85d6b..97efe1431 100644 --- a/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingTupleType.cs +++ b/src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingTupleType.cs @@ -14,6 +14,7 @@ // permissions and limitations under the License. using System.Collections.Generic; +using System.Diagnostics; using System.Linq; using Microsoft.Python.Analysis.Specializations.Typing.Values; using Microsoft.Python.Analysis.Types; @@ -28,16 +29,20 @@ internal class TypingTupleType : PythonCollectionType, ITypingTupleType { /// Creates type info for a strongly-typed tuple, such as Tuple[T1, T2, ...]. /// /// Tuple item types. + /// Declaring module. If null, then 'typing' is assumed. /// Python interpreter. - public TypingTupleType(IReadOnlyList itemTypes, IPythonInterpreter interpreter) - : base(null, BuiltinTypeId.Tuple, interpreter.ModuleResolution.GetSpecializedModule("typing"), false) { - ItemTypes = itemTypes; + public TypingTupleType(IReadOnlyList itemTypes, IPythonModule declaringModule, IPythonInterpreter interpreter) + : base(BuiltinTypeId.Tuple, declaringModule ?? interpreter.ModuleResolution.GetSpecializedModule("typing"), false) { + ItemTypes = itemTypes.Count > 0 ? itemTypes : new[] { interpreter.UnknownType }; Name = CodeFormatter.FormatSequence("Tuple", '[', itemTypes); + QualifiedName = CodeFormatter.FormatSequence("typing:Tuple", '[', itemTypes.Select(t => t.QualifiedName)); } public IReadOnlyList ItemTypes { get; } public override string Name { get; } + public override string QualifiedName { get; } + public override bool IsAbstract => false; public override bool IsSpecialized => true; @@ -73,7 +78,7 @@ public override bool Equals(object obj) { return true; } - public override int GetHashCode() + public override int GetHashCode() => ItemTypes.Aggregate(0, (current, item) => current ^ item.GetHashCode()) ^ Name.GetHashCode(); } } diff --git a/src/Analysis/Ast/Impl/Specializations/Typing/TypingModule.cs b/src/Analysis/Ast/Impl/Specializations/Typing/TypingModule.cs index 9964e3d66..d0a3b18b7 100644 --- a/src/Analysis/Ast/Impl/Specializations/Typing/TypingModule.cs +++ b/src/Analysis/Ast/Impl/Specializations/Typing/TypingModule.cs @@ -60,8 +60,8 @@ private void SpecializeMembers() { // When called, create generic parameter type. For documentation // use original TypeVar declaration so it appear as a tooltip. - o.SetReturnValueProvider((interpreter, overload, args) - => GenericTypeParameter.FromTypeVar(args, interpreter)); + o.SetReturnValueProvider((declaringModule, overload, args) + => GenericTypeParameter.FromTypeVar(args, declaringModule)); fn.AddOverload(o); _members["TypeVar"] = fn; @@ -71,7 +71,7 @@ private void SpecializeMembers() { o = new PythonFunctionOverload(fn.Name, location); // When called, create generic parameter type. For documentation // use original TypeVar declaration so it appear as a tooltip. - o.SetReturnValueProvider((interpreter, overload, args) => CreateTypeAlias(args)); + o.SetReturnValueProvider((declaringModule, overload, args) => CreateTypeAlias(args)); fn.AddOverload(o); _members["NewType"] = fn; @@ -80,7 +80,7 @@ private void SpecializeMembers() { o = new PythonFunctionOverload(fn.Name, location); // When called, create generic parameter type. For documentation // use original TypeVar declaration so it appear as a tooltip. - o.SetReturnValueProvider((interpreter, overload, args) => { + o.SetReturnValueProvider((declaringModule, overload, args) => { var a = args.Values(); return a.Count == 1 ? a[0] : Interpreter.UnknownType; }); @@ -136,12 +136,11 @@ private void SpecializeMembers() { fn = PythonFunctionType.Specialize("NamedTuple", this, GetMemberDocumentation("NamedTuple")); o = new PythonFunctionOverload(fn.Name, location); - o.SetReturnValueProvider((interpreter, overload, args) => CreateNamedTuple(args.Values())); + o.SetReturnValueProvider((declaringModule, overload, args) => CreateNamedTuple(args.Values(), declaringModule)); fn.AddOverload(o); _members["NamedTuple"] = fn; _members["Any"] = new AnyType(this); - _members["AnyStr"] = CreateAnyStr(); _members["Optional"] = new GenericType("Optional", CreateOptional, this); @@ -241,8 +240,8 @@ private IPythonType CreateTypeAlias(IArgumentSet args) { eval.ReportDiagnostics( eval.Module?.Uri, - new DiagnosticsEntry(Resources.NewTypeFirstArgNotString.FormatInvariant(firstArgType), - expression?.GetLocation(eval)?.Span ?? default, + new DiagnosticsEntry(Resources.NewTypeFirstArgNotString.FormatInvariant(firstArgType), + expression?.GetLocation(eval)?.Span ?? default, Diagnostics.ErrorCodes.TypingNewTypeArguments, Severity.Warning, DiagnosticSource.Analysis) ); @@ -259,7 +258,7 @@ private IPythonType CreateUnion(IReadOnlyList typeArgs) { return Interpreter.UnknownType; } - private IPythonType CreateNamedTuple(IReadOnlyList typeArgs) { + private IPythonType CreateNamedTuple(IReadOnlyList typeArgs, IPythonModule declaringModule) { if (typeArgs.Count != 2) { // TODO: report wrong number of arguments return Interpreter.UnknownType; @@ -304,7 +303,7 @@ private IPythonType CreateNamedTuple(IReadOnlyList typeArgs) { itemNames.Add(itemName2); itemTypes.Add(c.Contents[1].GetPythonType()); } - return TypingTypeFactory.CreateNamedTupleType(Interpreter, tupleName, itemNames, itemTypes); + return TypingTypeFactory.CreateNamedTupleType(Interpreter, tupleName, itemNames, itemTypes, declaringModule); } private IPythonType CreateOptional(IReadOnlyList typeArgs) { @@ -327,15 +326,14 @@ private IPythonType CreateAnyStr() { var str = Interpreter.GetBuiltinType(BuiltinTypeId.Str); var bytes = Interpreter.GetBuiltinType(BuiltinTypeId.Bytes); var unicode = Interpreter.GetBuiltinType(BuiltinTypeId.Unicode); - var name = "AnyStr"; var constraints = Interpreter.LanguageVersion.Is3x() - ? new IPythonType[] { str, bytes } - : new IPythonType[] { str, unicode }; - var docArgs = new[] { $"'{name}'" }.Concat(constraints.Select(c => c.Name)); - var documentation = CodeFormatter.FormatSequence("TypeVar", '(', docArgs); + ? new[] { str, bytes } + : new[] { str, unicode }; + var docArgs = new[] { "'AnyStr'" }.Concat(constraints.Select(c => c.Name)); - return new GenericTypeParameter(name, this, constraints, documentation, default); + var documentation = CodeFormatter.FormatSequence("TypeVar", '(', docArgs); + return new PythonTypeWrapper("AnyStr", documentation, this, Interpreter.GetBuiltinType(BuiltinTypeId.Str)); } private IPythonType CreateGenericClassParameter(IReadOnlyList typeArgs) { diff --git a/src/Analysis/Ast/Impl/Specializations/Typing/TypingTypeFactory.cs b/src/Analysis/Ast/Impl/Specializations/Typing/TypingTypeFactory.cs index afed8ded6..540615aac 100644 --- a/src/Analysis/Ast/Impl/Specializations/Typing/TypingTypeFactory.cs +++ b/src/Analysis/Ast/Impl/Specializations/Typing/TypingTypeFactory.cs @@ -26,7 +26,7 @@ public static ITypingListType CreateListType(IPythonInterpreter interpreter, str => new TypingListType(typeName, typeId, itemType, interpreter, isMutable); public static ITypingTupleType CreateTupleType(IPythonInterpreter interpreter, IReadOnlyList types) - => new TypingTupleType(types, interpreter); + => new TypingTupleType(types, null, interpreter); public static ITypingIteratorType CreateIteratorType(IPythonInterpreter interpreter, IPythonType itemType) => new TypingIteratorType(itemType, BuiltinTypeId.ListIterator, interpreter); @@ -55,8 +55,8 @@ public static ITypingListType CreateItemsViewType(IPythonInterpreter interpreter public static IPythonType CreateUnionType(IPythonInterpreter interpreter, IReadOnlyList types, IPythonModule declaringModule) => new PythonUnionType(types.Select(a => a.GetPythonType()), declaringModule); - public static ITypingNamedTupleType CreateNamedTupleType(IPythonInterpreter interpreter, string tupleName, IReadOnlyList itemNames, IReadOnlyList itemTypes) - => new NamedTupleType(tupleName, itemNames, itemTypes, interpreter); + public static ITypingNamedTupleType CreateNamedTupleType(IPythonInterpreter interpreter, string tupleName, IReadOnlyList itemNames, IReadOnlyList itemTypes, IPythonModule declaringModule) + => new NamedTupleType(tupleName, itemNames, itemTypes, declaringModule, interpreter); public static IPythonType CreateOptionalType(IPythonModule declaringModule, IPythonType type) => new OptionalType(declaringModule, type); diff --git a/src/Analysis/Ast/Impl/Types/ArgumentSet.cs b/src/Analysis/Ast/Impl/Types/ArgumentSet.cs index e84c4a165..ae1f9fe39 100644 --- a/src/Analysis/Ast/Impl/Types/ArgumentSet.cs +++ b/src/Analysis/Ast/Impl/Types/ArgumentSet.cs @@ -17,7 +17,6 @@ using System.Collections.Generic; using System.IO; using System.Linq; -using System.Runtime.CompilerServices; using Microsoft.Python.Analysis.Analyzer; using Microsoft.Python.Analysis.Diagnostics; using Microsoft.Python.Analysis.Values; diff --git a/src/Analysis/Ast/Impl/Types/Collections/PythonCollectionType.cs b/src/Analysis/Ast/Impl/Types/Collections/PythonCollectionType.cs index 00cdef76e..e8e6f598f 100644 --- a/src/Analysis/Ast/Impl/Types/Collections/PythonCollectionType.cs +++ b/src/Analysis/Ast/Impl/Types/Collections/PythonCollectionType.cs @@ -25,22 +25,17 @@ namespace Microsoft.Python.Analysis.Types.Collections { /// Type info for an iterable entity. Most base collection class. /// internal class PythonCollectionType : PythonTypeWrapper, IPythonCollectionType { - private string _typeName; - /// /// Creates type info for an collection. /// - /// Iterable type name. If null, name of the type id will be used. /// Collection type id, such as . /// Declaring module. /// Indicates if collection is mutable (like list) or immutable (like tuple). public PythonCollectionType( - string typeName, BuiltinTypeId collectionTypeId, IPythonModule declaringModule, bool isMutable ) : base(collectionTypeId, declaringModule) { - _typeName = typeName; TypeId = collectionTypeId; IteratorType = new PythonIteratorType(collectionTypeId.GetIteratorTypeId(), declaringModule); IsMutable = isMutable; @@ -56,18 +51,6 @@ bool isMutable #endregion #region IPythonType - public override string Name { - get { - if (_typeName == null) { - var type = DeclaringModule.Interpreter.GetBuiltinType(TypeId); - if (!type.IsUnknown()) { - _typeName = type.Name; - } - } - return _typeName ?? ""; ; - } - } - public override BuiltinTypeId TypeId { get; } public override PythonMemberType MemberType => PythonMemberType.Class; public override IMember GetMember(string name) => name == @"__iter__" ? IteratorType : base.GetMember(name); @@ -98,7 +81,7 @@ public static IPythonCollection CreateList(IPythonModule declaringModule, IArgum } public static IPythonCollection CreateList(IPythonModule declaringModule, IReadOnlyList contents, bool flatten = true, bool exact = false) { - var collectionType = new PythonCollectionType(null, BuiltinTypeId.List, declaringModule, true); + var collectionType = new PythonCollectionType(BuiltinTypeId.List, declaringModule, true); return new PythonCollection(collectionType, contents, flatten, exact: exact); } @@ -109,7 +92,7 @@ public static IPythonCollection CreateConcatenatedList(IPythonModule declaringMo } public static IPythonCollection CreateTuple(IPythonModule declaringModule, IReadOnlyList contents, bool exact = false) { - var collectionType = new PythonCollectionType(null, BuiltinTypeId.Tuple, declaringModule, false); + var collectionType = new PythonCollectionType(BuiltinTypeId.Tuple, declaringModule, false); return new PythonCollection(collectionType, contents, exact: exact); } @@ -120,7 +103,7 @@ public static IPythonCollection CreateConcatenatedTuple(IPythonModule declaringM } public static IPythonCollection CreateSet(IPythonModule declaringModule, IReadOnlyList contents, bool flatten = true, bool exact = false) { - var collectionType = new PythonCollectionType(null, BuiltinTypeId.Set, declaringModule, true); + var collectionType = new PythonCollectionType(BuiltinTypeId.Set, declaringModule, true); return new PythonCollection(collectionType, contents, flatten, exact: exact); } diff --git a/src/Analysis/Ast/Impl/Types/Collections/PythonDictionaryType.cs b/src/Analysis/Ast/Impl/Types/Collections/PythonDictionaryType.cs index 855339441..a4835deec 100644 --- a/src/Analysis/Ast/Impl/Types/Collections/PythonDictionaryType.cs +++ b/src/Analysis/Ast/Impl/Types/Collections/PythonDictionaryType.cs @@ -20,7 +20,7 @@ namespace Microsoft.Python.Analysis.Types.Collections { internal class PythonDictionaryType : PythonCollectionType { public PythonDictionaryType(IPythonModule declaringModule, bool isMutable = true) - : base(null, BuiltinTypeId.Dict, declaringModule, isMutable) { + : base(BuiltinTypeId.Dict, declaringModule, isMutable) { } public override IMember CreateInstance(string typeName, IArgumentSet args) { diff --git a/src/Analysis/Ast/Impl/Types/Definitions/IPythonClassType.cs b/src/Analysis/Ast/Impl/Types/Definitions/IPythonClassType.cs index 852860bef..aa42faee9 100644 --- a/src/Analysis/Ast/Impl/Types/Definitions/IPythonClassType.cs +++ b/src/Analysis/Ast/Impl/Types/Definitions/IPythonClassType.cs @@ -20,7 +20,7 @@ namespace Microsoft.Python.Analysis.Types { /// /// Represents Python class type definition. /// - public interface IPythonClassType : IPythonType { + public interface IPythonClassType : IPythonClassMember { /// /// Class definition node in the AST. /// diff --git a/src/Analysis/Ast/Impl/Types/Definitions/IPythonFunctionOverload.cs b/src/Analysis/Ast/Impl/Types/Definitions/IPythonFunctionOverload.cs index f71505cb8..2f8706a8e 100644 --- a/src/Analysis/Ast/Impl/Types/Definitions/IPythonFunctionOverload.cs +++ b/src/Analysis/Ast/Impl/Types/Definitions/IPythonFunctionOverload.cs @@ -53,7 +53,6 @@ public interface IPythonFunctionOverload { /// Call arguments or type arguments. /// Invoking class instance. In case of generics it is instance of the specific type /// as opposed to declaring type which is the generic template class. - /// Call expression location, if any. IMember Call(IArgumentSet args, IPythonType self); /// diff --git a/src/Analysis/Ast/Impl/Types/LocatedMember.cs b/src/Analysis/Ast/Impl/Types/LocatedMember.cs index 36899d865..2a70b4004 100644 --- a/src/Analysis/Ast/Impl/Types/LocatedMember.cs +++ b/src/Analysis/Ast/Impl/Types/LocatedMember.cs @@ -54,6 +54,9 @@ public virtual IReadOnlyList References { public virtual void AddReference(Location location) { lock (this) { + if(this.DeclaringModule == null || this.DeclaringModule?.ModuleType == ModuleType.Builtins) { + return; + } // Don't add references to library code. if (location.Module?.ModuleType == ModuleType.User && !location.Equals(Location)) { _references = _references ?? new HashSet(); diff --git a/src/Analysis/Ast/Impl/Types/PythonClassType.cs b/src/Analysis/Ast/Impl/Types/PythonClassType.cs index eae622a9c..a00dd76df 100644 --- a/src/Analysis/Ast/Impl/Types/PythonClassType.cs +++ b/src/Analysis/Ast/Impl/Types/PythonClassType.cs @@ -17,8 +17,6 @@ using System.Collections.Generic; using System.Diagnostics; using System.Linq; -using Microsoft.Python.Analysis.Analyzer; -using Microsoft.Python.Analysis.Diagnostics; using Microsoft.Python.Analysis.Modules; using Microsoft.Python.Analysis.Specializations.Typing; using Microsoft.Python.Analysis.Types.Collections; @@ -33,8 +31,15 @@ namespace Microsoft.Python.Analysis.Types { [DebuggerDisplay("Class {Name}")] internal class PythonClassType : PythonType, IPythonClassType, IPythonTemplateType, IEquatable { + internal enum ClassDocumentationSource { + Class, + Init, + Base + } + private static readonly string[] _classMethods = { "mro", "__dict__", @"__weakref__" }; + private readonly object _specificTypeLock = new object(); private Dictionary _specificTypeCache; private IPythonClassType _processing; private List _bases; @@ -50,15 +55,18 @@ internal PythonClassType(string name, Location location) public PythonClassType( ClassDefinition classDefinition, + IPythonType declaringType, Location location, BuiltinTypeId builtinTypeId = BuiltinTypeId.Type ) : base(classDefinition.Name, location, classDefinition.GetDocumentation(), builtinTypeId) { Check.ArgumentNotNull(nameof(location), location.Module); location.Module.AddAstNode(this, classDefinition); + DeclaringType = declaringType; } #region IPythonType public override PythonMemberType MemberType => PythonMemberType.Class; + public IPythonType DeclaringType { get; } public override IEnumerable GetMemberNames() { var names = new HashSet(); @@ -114,11 +122,14 @@ public override string Documentation { try { // Try doc from the type first (class definition AST node). _documentation = base.Documentation; + DocumentationSource = ClassDocumentationSource.Class; + if (string.IsNullOrEmpty(_documentation)) { // If not present, try docs __init__. IPythonFunctionType handles // __init__ in a special way so there is no danger of call coming // back here and causing stack overflow. _documentation = (GetMember("__init__") as IPythonFunctionType)?.Documentation; + DocumentationSource = ClassDocumentationSource.Init; } if (string.IsNullOrEmpty(_documentation) && Bases != null) { @@ -126,6 +137,7 @@ public override string Documentation { var o = DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Object); _documentation = Bases.FirstOrDefault(b => b != o && !string.IsNullOrEmpty(b?.Documentation)) ?.Documentation; + DocumentationSource = ClassDocumentationSource.Base; } } finally { Pop(); @@ -189,6 +201,9 @@ public IReadOnlyDictionary GenericParameters => _genericParameters ?? EmptyDictionary.Instance; #endregion + internal ClassDocumentationSource DocumentationSource { get; private set; } + internal override void SetDocumentation(string documentation) => _documentation = documentation; + internal void SetBases(IEnumerable bases) { if (_bases != null) { return; // Already set @@ -290,144 +305,146 @@ public bool Equals(IPythonClassType other) => Name == other?.Name && DeclaringModule.Equals(other?.DeclaringModule); public IPythonType CreateSpecificType(IArgumentSet args) { - // Get declared generic parameters of the class, i.e. list of Ts in Generic[T1, T2, ...] - var genericClassParameters = Bases.OfType().ToArray(); - // Optimistically use the first one - // TODO: handle optional generics as class A(Generic[_T1], Optional[Generic[_T2]]) - var genericClassParameter = genericClassParameters.FirstOrDefault(); - - // Create map of names listed in Generic[...] in the class definition. - // We will be filling the map with specific types, if any provided. - var genericTypeDefinitions = genericClassParameter?.TypeDefinitions ?? Array.Empty(); - var genericClassTypeParameters = genericTypeDefinitions.ToDictionary(td => td.Name, td => td); - - var specificClassTypeParameters = new Dictionary(); - var newBases = new List(); - - // Arguments passed are those of __init__ or it is a copy constructor. - // They do not necessarily match all of the declared generic parameters. - // Some generic parameters may be used to specify method return types or - // method arguments and do not appear in the constructor argument list. - // Figure out whatever specific types we can from the arguments. - foreach (var arg in args.Arguments) { - // The argument may either match generic type definition of be a specific type - // created off generic type. Consider '__init__(self, v: _T)' and - // 'class A(Generic[K, V], Mapping[K, V])'. - if (arg.Type is IGenericTypeDefinition argTypeDefinition) { - // Parameter is annotated as generic type definition. Check if its generic type - // name matches any of the generic class parameters. I.e. if there is - // an argument like 'v: _T' we need to check if class has matching Generic[_T]. - if (genericClassTypeParameters.ContainsKey(argTypeDefinition.Name)) { - // TODO: Check if specific type matches generic type definition constraints and report mismatches. - // Assign specific type. - if (arg.Value is IMember m && m.GetPythonType() is IPythonType pt) { - specificClassTypeParameters[argTypeDefinition.Name] = pt; + lock (_specificTypeLock) { + // Get declared generic parameters of the class, i.e. list of Ts in Generic[T1, T2, ...] + var genericClassParameters = Bases.OfType().ToArray(); + // Optimistically use the first one + // TODO: handle optional generics as class A(Generic[_T1], Optional[Generic[_T2]]) + var genericClassParameter = genericClassParameters.FirstOrDefault(); + + // Create map of names listed in Generic[...] in the class definition. + // We will be filling the map with specific types, if any provided. + var genericTypeDefinitions = genericClassParameter?.TypeDefinitions ?? Array.Empty(); + var genericClassTypeParameters = genericTypeDefinitions.ToDictionary(td => td.Name, td => td); + + var specificClassTypeParameters = new Dictionary(); + var newBases = new List(); + + // Arguments passed are those of __init__ or it is a copy constructor. + // They do not necessarily match all of the declared generic parameters. + // Some generic parameters may be used to specify method return types or + // method arguments and do not appear in the constructor argument list. + // Figure out whatever specific types we can from the arguments. + foreach (var arg in args.Arguments) { + // The argument may either match generic type definition of be a specific type + // created off generic type. Consider '__init__(self, v: _T)' and + // 'class A(Generic[K, V], Mapping[K, V])'. + if (arg.Type is IGenericTypeDefinition argTypeDefinition) { + // Parameter is annotated as generic type definition. Check if its generic type + // name matches any of the generic class parameters. I.e. if there is + // an argument like 'v: _T' we need to check if class has matching Generic[_T]. + if (genericClassTypeParameters.ContainsKey(argTypeDefinition.Name)) { + // TODO: Check if specific type matches generic type definition constraints and report mismatches. + // Assign specific type. + if (arg.Value is IMember m && m.GetPythonType() is IPythonType pt) { + specificClassTypeParameters[argTypeDefinition.Name] = pt; + } else { + // TODO: report supplied parameter is not a type. + } } else { - // TODO: report supplied parameter is not a type. + // TODO: report generic parameter name mismatch. } - } else { - // TODO: report generic parameter name mismatch. - } - continue; - } - - if (arg.Value is IMember member && !member.GetPythonType().IsUnknown()) { - var type = member.GetPythonType(); - // Type may be a specific type created off generic or just a type - // for the copy constructor. Consider 'class A(Generic[K, V], Mapping[K, V])' - // constructed as 'd = {1:'a', 2:'b'}; A(d)'. Here we look through bases - // and see if any matches the builtin type id. For example, Mapping or Dict - // will have BultinTypeId.Dict and we can figure out specific types from - // the content of the collection. - var b = _bases.OfType().FirstOrDefault(x => x.TypeId == type.TypeId); - if (b != null && b.Parameters.Count > 0) { - newBases.Add(type); - // Optimistically assign argument types if they match. - // Handle common cases directly. - GetSpecificTypeFromArgumentValue(b, arg.Value, specificClassTypeParameters); continue; } - // Any regular base match? - if (_bases.Any(x => x.TypeId == type.TypeId) && !type.Equals(this)) { - newBases.Add(type); + if (arg.Value is IMember member && !member.GetPythonType().IsUnknown()) { + var type = member.GetPythonType(); + // Type may be a specific type created off generic or just a type + // for the copy constructor. Consider 'class A(Generic[K, V], Mapping[K, V])' + // constructed as 'd = {1:'a', 2:'b'}; A(d)'. Here we look through bases + // and see if any matches the builtin type id. For example, Mapping or Dict + // will have BultinTypeId.Dict and we can figure out specific types from + // the content of the collection. + var b = _bases.OfType().FirstOrDefault(x => x.TypeId == type.TypeId); + if (b != null && b.Parameters.Count > 0) { + newBases.Add(type); + // Optimistically assign argument types if they match. + // Handle common cases directly. + GetSpecificTypeFromArgumentValue(b, arg.Value, specificClassTypeParameters); + continue; + } + + // Any regular base match? + if (_bases.Any(x => x.TypeId == type.TypeId) && !type.Equals(this)) { + newBases.Add(type); + } } } - } - // For still undefined parameters try matching passed types in order - for (int i = 0, gtIndex = 0; i < args.Arguments.Count; i++) { - var arg = args.Arguments[i]; - if (Equals(arg.Type)) { - continue; // Typically 'self'. - } + // For still undefined parameters try matching passed types in order + for (int i = 0, gtIndex = 0; i < args.Arguments.Count; i++) { + var arg = args.Arguments[i]; + if (Equals(arg.Type)) { + continue; // Typically 'self'. + } - if (arg.Value is IMember member) { - var type = member.GetPythonType(); - if (!type.IsUnknown()) { - var gtd = gtIndex < genericTypeDefinitions.Count ? genericTypeDefinitions[gtIndex] : null; - if (gtd != null && !specificClassTypeParameters.ContainsKey(gtd.Name)) { - specificClassTypeParameters[gtd.Name] = type; + if (arg.Value is IMember member) { + var type = member.GetPythonType(); + if (!type.IsUnknown()) { + var gtd = gtIndex < genericTypeDefinitions.Count ? genericTypeDefinitions[gtIndex] : null; + if (gtd != null && !specificClassTypeParameters.ContainsKey(gtd.Name)) { + specificClassTypeParameters[gtd.Name] = type; + } + gtIndex++; } - gtIndex++; } } - } - // Define specific type in the original order - var specificTypes = genericTypeDefinitions - .Select(p => specificClassTypeParameters.TryGetValue(p.Name, out var v) ? v : null) - .ExcludeDefault() - .ToArray(); + // Define specific type in the original order + var specificTypes = genericTypeDefinitions + .Select(p => specificClassTypeParameters.TryGetValue(p.Name, out var v) ? v : null) + .ExcludeDefault() + .ToArray(); - var specificName = CodeFormatter.FormatSequence(Name, '[', specificTypes); - _specificTypeCache = _specificTypeCache ?? new Dictionary(); - if (_specificTypeCache.TryGetValue(specificName, out var classType)) { - return classType; - } - _specificTypeCache[specificName] = classType = new PythonClassType(specificName, new Location(DeclaringModule)); + var specificName = CodeFormatter.FormatSequence(Name, '[', specificTypes); + _specificTypeCache = _specificTypeCache ?? new Dictionary(); + if (_specificTypeCache.TryGetValue(specificName, out var classType)) { + return classType; + } + _specificTypeCache[specificName] = classType = new PythonClassType(specificName, new Location(DeclaringModule)); - // Methods returning generic types need to know how to match generic - // parameter name to the actual supplied type. - StoreGenericParameters(classType, genericTypeDefinitions.ToArray(), specificTypes); + // Methods returning generic types need to know how to match generic + // parameter name to the actual supplied type. + StoreGenericParameters(classType, genericTypeDefinitions.ToArray(), specificTypes); - // Prevent reentrancy when resolving generic class where - // method may be returning instance of type of the same class. - if (!Push(classType)) { - return _processing; - } + // Prevent reentrancy when resolving generic class where + // method may be returning instance of type of the same class. + if (!Push(classType)) { + return _processing; + } - try { - // Create specific bases since we may have generic types there. - // Match generic parameter names to base type parameter names. - // Consider 'class A(Generic[T], B[T], C[E]): ...' - var genericTypeBases = Bases.Except(genericClassParameters).OfType().ToArray(); - // Start with regular types, then add specific types for all generic types. - var bases = Bases.Except(genericTypeBases).Except(genericClassParameters).ToList(); - - // Create specific types for generic type bases - // it for generic types but not Generic[T, ...] itself. - foreach (var gt in genericTypeBases) { - var st = gt.Parameters - .Select(p => classType.GenericParameters.TryGetValue(p.Name, out var t) ? t : null) - .Where(p => !p.IsUnknown()) - .ToArray(); - if (st.Length > 0) { - var type = gt.CreateSpecificType(new ArgumentSet(st, args.Expression, args.Eval)); - if (!type.IsUnknown()) { - bases.Add(type); + try { + // Create specific bases since we may have generic types there. + // Match generic parameter names to base type parameter names. + // Consider 'class A(Generic[T], B[T], C[E]): ...' + var genericTypeBases = Bases.Except(genericClassParameters).OfType().ToArray(); + // Start with regular types, then add specific types for all generic types. + var bases = Bases.Except(genericTypeBases).Except(genericClassParameters).ToList(); + + // Create specific types for generic type bases + // it for generic types but not Generic[T, ...] itself. + foreach (var gt in genericTypeBases) { + var st = gt.Parameters + .Select(p => classType.GenericParameters.TryGetValue(p.Name, out var t) ? t : null) + .Where(p => !p.IsUnknown()) + .ToArray(); + if (st.Length > 0) { + var type = gt.CreateSpecificType(new ArgumentSet(st, args.Expression, args.Eval)); + if (!type.IsUnknown()) { + bases.Add(type); + } } } - } - // Set specific class bases - classType.SetBases(bases.Concat(newBases)); - // Transfer members from generic to specific type. - SetClassMembers(classType, args); - } finally { - Pop(); + // Set specific class bases + classType.SetBases(bases.Concat(newBases)); + // Transfer members from generic to specific type. + SetClassMembers(classType, args); + } finally { + Pop(); + } + return classType; } - return classType; } private void StoreGenericParameters(PythonClassType classType, IGenericTypeDefinition[] genericParameters, IPythonType[] specificTypes) { diff --git a/src/Analysis/Ast/Impl/Types/PythonFunctionOverload.cs b/src/Analysis/Ast/Impl/Types/PythonFunctionOverload.cs index d1c5033fb..48e7d161a 100644 --- a/src/Analysis/Ast/Impl/Types/PythonFunctionOverload.cs +++ b/src/Analysis/Ast/Impl/Types/PythonFunctionOverload.cs @@ -116,7 +116,7 @@ public string GetReturnDocumentation(IPythonType self = null) { public IMember Call(IArgumentSet args, IPythonType self) { if (!_fromAnnotation) { // First try supplied specialization callback. - var rt = _returnValueProvider?.Invoke(DeclaringModule, this, args); + var rt = _returnValueProvider?.Invoke(args.Eval.Module, this, args); if (!rt.IsUnknown()) { return rt; } diff --git a/src/Analysis/Ast/Impl/Types/PythonFunctionType.cs b/src/Analysis/Ast/Impl/Types/PythonFunctionType.cs index a0f6079e2..03150f13f 100644 --- a/src/Analysis/Ast/Impl/Types/PythonFunctionType.cs +++ b/src/Analysis/Ast/Impl/Types/PythonFunctionType.cs @@ -16,6 +16,7 @@ using System.Collections.Generic; using System.Diagnostics; using System.Linq; +using Microsoft.Python.Analysis.Modules; using Microsoft.Python.Analysis.Values; using Microsoft.Python.Core; using Microsoft.Python.Core.Collections; @@ -51,7 +52,7 @@ public PythonFunctionType( Location location, IPythonType declaringType, string documentation - ) : base(name, location, documentation, declaringType != null ? BuiltinTypeId.Method : BuiltinTypeId.Function) { + ) : base(name, location, documentation, declaringType is IPythonClassType ? BuiltinTypeId.Method : BuiltinTypeId.Function) { DeclaringType = declaringType; } @@ -61,8 +62,13 @@ public PythonFunctionType( Location location ) : base(fd.Name, location, fd.Name == "__init__" ? (declaringType?.Documentation ?? fd.GetDocumentation()) : fd.GetDocumentation(), - declaringType != null ? BuiltinTypeId.Method : BuiltinTypeId.Function) { + declaringType is IPythonClassType ? BuiltinTypeId.Method : BuiltinTypeId.Function) { DeclaringType = declaringType; + + // IsStub must be set permanently so when location of the stub is reassigned + // to the primary module for navigation purposes, function still remembers + // that it case from a stub. + IsStub = location.Module.ModuleType == ModuleType.Stub; location.Module.AddAstNode(this, fd); ProcessDecorators(fd); @@ -99,7 +105,7 @@ internal override void SetDocumentation(string documentation) { public override bool IsSpecialized => _isSpecialized; public bool IsOverload { get; private set; } - public bool IsStub { get; internal set; } + public bool IsStub { get; } public bool IsUnbound => DeclaringType == null; public IReadOnlyList Overloads => _overloads; @@ -117,7 +123,10 @@ internal void Specialize(string[] dependencies) { internal void AddOverload(IPythonFunctionOverload overload) => _overloads = _overloads.Count > 0 ? _overloads.Add(overload) : ImmutableArray.Create(overload); - internal IPythonFunctionType ToUnbound() => new PythonUnboundMethod(this); + internal IPythonFunctionType ToUnbound() { + Debug.Assert(DeclaringType != null, "Attempt to unbound standalone function."); + return new PythonUnboundMethod(this); + } private void ProcessDecorators(FunctionDefinition fd) { foreach (var dec in (fd.Decorators?.Decorators).MaybeEnumerate().OfType()) { @@ -154,22 +163,21 @@ private void ProcessDecorators(FunctionDefinition fd) { /// /// Represents unbound method, such in C.f where C is class rather than the instance. /// - private sealed class PythonUnboundMethod : PythonTypeWrapper, IPythonFunctionType { - private readonly IPythonFunctionType _pf; - + internal sealed class PythonUnboundMethod : PythonTypeWrapper, IPythonFunctionType { public PythonUnboundMethod(IPythonFunctionType function) : base(function, function.DeclaringModule) { - _pf = function; + Function = function; } - public FunctionDefinition FunctionDefinition => _pf.FunctionDefinition; - public IPythonType DeclaringType => _pf.DeclaringType; - public bool IsStatic => _pf.IsStatic; - public bool IsClassMethod => _pf.IsClassMethod; - public bool IsOverload => _pf.IsOverload; - public bool IsStub => _pf.IsStub; + public IPythonFunctionType Function { get; } + public FunctionDefinition FunctionDefinition => Function.FunctionDefinition; + public IPythonType DeclaringType => Function.DeclaringType; + public bool IsStatic => Function.IsStatic; + public bool IsClassMethod => Function.IsClassMethod; + public bool IsOverload => Function.IsOverload; + public bool IsStub => Function.IsStub; public bool IsUnbound => true; - public IReadOnlyList Overloads => _pf.Overloads; + public IReadOnlyList Overloads => Function.Overloads; public override BuiltinTypeId TypeId => BuiltinTypeId.Function; public override PythonMemberType MemberType => PythonMemberType.Function; } diff --git a/src/Analysis/Ast/Impl/Types/PythonType.cs b/src/Analysis/Ast/Impl/Types/PythonType.cs index 503592fdf..eaf746d22 100644 --- a/src/Analysis/Ast/Impl/Types/PythonType.cs +++ b/src/Analysis/Ast/Impl/Types/PythonType.cs @@ -52,6 +52,14 @@ private PythonType(string name, Location location, BuiltinTypeId typeId) : base( #region ILocatedMember public override PythonMemberType MemberType => _typeId.GetMemberId(); + + public override void AddReference(Location location) { + if (DeclaringModule == null || DeclaringModule.ModuleType == ModuleType.Builtins) { + return; + } + + base.AddReference(location); + } #endregion #region IPythonType @@ -61,7 +69,7 @@ private PythonType(string name, Location location, BuiltinTypeId typeId) : base( public virtual string QualifiedName => DeclaringModule.ModuleType == ModuleType.Builtins ? TypeId == BuiltinTypeId.Ellipsis ? "ellipsis" : Name - : $"{DeclaringModule.Name}:{Name}"; + : this.GetQualifiedName(); public virtual string Documentation { get; private set; } public virtual BuiltinTypeId TypeId => _typeId; diff --git a/src/Analysis/Ast/Impl/Types/PythonTypeWrapper.cs b/src/Analysis/Ast/Impl/Types/PythonTypeWrapper.cs index 063820faa..5265555fc 100644 --- a/src/Analysis/Ast/Impl/Types/PythonTypeWrapper.cs +++ b/src/Analysis/Ast/Impl/Types/PythonTypeWrapper.cs @@ -23,6 +23,8 @@ namespace Microsoft.Python.Analysis.Types { /// internal class PythonTypeWrapper : IPythonType { private readonly BuiltinTypeId _builtinTypeId; + private readonly string _typeName; + private readonly string _documentation; private IPythonType _innerType; protected IPythonType InnerType @@ -32,7 +34,11 @@ protected IPythonType InnerType /// Creates delegate type wrapper over an existing type. /// Use dedicated constructor for wrapping builtin types. /// - public PythonTypeWrapper(IPythonType type) : this(type, type.DeclaringModule) { + public PythonTypeWrapper(IPythonType type) : this(type, type.DeclaringModule) { } + + public PythonTypeWrapper(string typeName, string documentation, IPythonModule declaringModule, IPythonType baseType) : this(baseType, declaringModule) { + _typeName = typeName; + _documentation = documentation; } /// @@ -55,10 +61,10 @@ public PythonTypeWrapper(BuiltinTypeId builtinTypeId, IPythonModule declaringMod } #region IPythonType - public virtual string Name => InnerType.Name; - public virtual string QualifiedName => InnerType.QualifiedName; + public virtual string Name => _typeName ?? InnerType.Name; + public virtual string QualifiedName => _typeName != null ? $"{DeclaringModule.Name}:{_typeName}" : InnerType.QualifiedName; public IPythonModule DeclaringModule { get; } - public virtual string Documentation => InnerType.Documentation; + public virtual string Documentation => _documentation ?? InnerType.Documentation; public virtual BuiltinTypeId TypeId => InnerType.TypeId; public virtual PythonMemberType MemberType => InnerType.MemberType; public virtual bool IsBuiltin => InnerType.IsBuiltin; diff --git a/src/Analysis/Ast/Impl/Values/Collections/PythonIterator.cs b/src/Analysis/Ast/Impl/Values/Collections/PythonIterator.cs index e97263f34..835feabac 100644 --- a/src/Analysis/Ast/Impl/Values/Collections/PythonIterator.cs +++ b/src/Analysis/Ast/Impl/Values/Collections/PythonIterator.cs @@ -38,7 +38,7 @@ public PythonIterator(IPythonType iteratorType, IPythonCollection collection) : private IArgumentSet GetArgSet(int index) { var newArg = new PythonConstant(index, Type.DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Int)); - return new ArgumentSet(new List() { newArg }, null, null); + return new ArgumentSet(new List { newArg }, null, null); } public override IMember Call(string memberName, IArgumentSet args) { diff --git a/src/Analysis/Ast/Test/BasicTests.cs b/src/Analysis/Ast/Test/BasicTests.cs index e82c400d1..a469fdddc 100644 --- a/src/Analysis/Ast/Test/BasicTests.cs +++ b/src/Analysis/Ast/Test/BasicTests.cs @@ -13,15 +13,12 @@ // See the Apache Version 2.0 License for specific language governing // permissions and limitations under the License. -using System.Linq; using System.Threading.Tasks; using FluentAssertions; using Microsoft.Python.Analysis.Tests.FluentAssertions; using Microsoft.Python.Analysis.Types; using Microsoft.Python.Analysis.Values; -using Microsoft.Python.Parsing; using Microsoft.Python.Parsing.Tests; -using Microsoft.Python.Tests.Utilities.FluentAssertions; using Microsoft.VisualStudio.TestTools.UnitTesting; using TestUtilities; @@ -82,56 +79,5 @@ import sys .HaveVariable("sys").OfType(BuiltinTypeId.Module) .And.HaveVariable("x").OfType(BuiltinTypeId.List); } - - [DataRow(true, true)] - [DataRow(false, true)] - [DataRow(true, false)] - [DataRow(false, false)] - [DataTestMethod, Priority(0)] - public async Task UnknownType(bool isPython3X, bool isAnaconda) { - const string code = @"x = 1"; - - var configuration = isPython3X - ? isAnaconda ? PythonVersions.LatestAnaconda3X : PythonVersions.LatestAvailable3X - : isAnaconda ? PythonVersions.LatestAnaconda2X : PythonVersions.LatestAvailable2X; - var analysis = await GetAnalysisAsync(code, configuration); - - var unkType = analysis.Document.Interpreter.UnknownType; - unkType.TypeId.Should().Be(BuiltinTypeId.Unknown); - } - - [DataRow(true, true)] - [DataRow(false, true)] - [DataRow(true, false)] - [DataRow(false, false)] - [DataTestMethod, Priority(0)] - public async Task BuiltinsTest(bool isPython3X, bool isAnaconda) { - const string code = @" -x = 1 -"; - var configuration = isPython3X - ? isAnaconda ? PythonVersions.LatestAnaconda3X : PythonVersions.LatestAvailable3X - : isAnaconda ? PythonVersions.LatestAnaconda2X : PythonVersions.LatestAvailable2X; - var analysis = await GetAnalysisAsync(code, configuration); - - var v = analysis.Should().HaveVariable("x").Which; - var t = v.Value.GetPythonType(); - t.Should().BeAssignableTo(); - - var mc = (IMemberContainer)t; - var names = mc.GetMemberNames().ToArray(); - names.Length.Should().BeGreaterThan(50); - } - - [TestMethod, Priority(0)] - public async Task BuiltinsTrueFalse() { - const string code = @" -booltypetrue = True -booltypefalse = False -"; - var analysis = await GetAnalysisAsync(code); - analysis.Should().HaveVariable(@"booltypetrue").OfType(BuiltinTypeId.Bool) - .And.HaveVariable(@"booltypefalse").OfType(BuiltinTypeId.Bool); - } } } diff --git a/src/Analysis/Ast/Test/BuiltinsTests.cs b/src/Analysis/Ast/Test/BuiltinsTests.cs new file mode 100644 index 000000000..04860f26c --- /dev/null +++ b/src/Analysis/Ast/Test/BuiltinsTests.cs @@ -0,0 +1,99 @@ +// Copyright(c) Microsoft Corporation +// All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the License); you may not use +// this file except in compliance with the License. You may obtain a copy of the +// License at http://www.apache.org/licenses/LICENSE-2.0 +// +// THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS +// OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY +// IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +// MERCHANTABILITY OR NON-INFRINGEMENT. +// +// See the Apache Version 2.0 License for specific language governing +// permissions and limitations under the License. + +using System.Linq; +using System.Threading.Tasks; +using FluentAssertions; +using Microsoft.Python.Analysis.Tests.FluentAssertions; +using Microsoft.Python.Analysis.Types; +using Microsoft.Python.Parsing.Tests; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using TestUtilities; + +namespace Microsoft.Python.Analysis.Tests { + [TestClass] + public class BuiltinsTests : AnalysisTestBase { + public TestContext TestContext { get; set; } + + [TestInitialize] + public void TestInitialize() + => TestEnvironmentImpl.TestInitialize($"{TestContext.FullyQualifiedTestClassName}.{TestContext.TestName}"); + + [TestCleanup] + public void Cleanup() => TestEnvironmentImpl.TestCleanup(); + + + [DataRow(true, true)] + [DataRow(false, true)] + [DataRow(true, false)] + [DataRow(false, false)] + [DataTestMethod, Priority(0)] + public async Task BuiltinsTest(bool isPython3X, bool isAnaconda) { + const string code = @" +x = 1 +"; + var configuration = isPython3X + ? isAnaconda ? PythonVersions.LatestAnaconda3X : PythonVersions.LatestAvailable3X + : isAnaconda ? PythonVersions.LatestAnaconda2X : PythonVersions.LatestAvailable2X; + var analysis = await GetAnalysisAsync(code, configuration); + + var v = analysis.Should().HaveVariable("x").Which; + var t = v.Value.GetPythonType(); + t.Should().BeAssignableTo(); + + var mc = (IMemberContainer)t; + var names = mc.GetMemberNames().ToArray(); + names.Length.Should().BeGreaterThan(50); + } + + [TestMethod, Priority(0)] + public async Task BuiltinsTrueFalse() { + const string code = @" +booltypetrue = True +booltypefalse = False +"; + var analysis = await GetAnalysisAsync(code); + analysis.Should().HaveVariable(@"booltypetrue").OfType(BuiltinTypeId.Bool) + .And.HaveVariable(@"booltypefalse").OfType(BuiltinTypeId.Bool); + } + + [DataRow(true, true)] + [DataRow(false, true)] + [DataRow(true, false)] + [DataRow(false, false)] + [DataTestMethod, Priority(0)] + public async Task UnknownType(bool isPython3X, bool isAnaconda) { + const string code = @"x = 1"; + + var configuration = isPython3X + ? isAnaconda ? PythonVersions.LatestAnaconda3X : PythonVersions.LatestAvailable3X + : isAnaconda ? PythonVersions.LatestAnaconda2X : PythonVersions.LatestAvailable2X; + var analysis = await GetAnalysisAsync(code, configuration); + + var unkType = analysis.Document.Interpreter.UnknownType; + unkType.TypeId.Should().Be(BuiltinTypeId.Unknown); + } + + [TestMethod, Priority(0)] + public async Task Type() { + const string code = @" +class _C: + def _m(self): pass +MethodType = type(_C()._m)"; + var analysis = await GetAnalysisAsync(code); + analysis.Should().HaveVariable(@"MethodType").OfType(BuiltinTypeId.Method); + } + } +} diff --git a/src/Analysis/Ast/Test/ClassesTests.cs b/src/Analysis/Ast/Test/ClassesTests.cs index 1d817f3cb..8b774b61a 100644 --- a/src/Analysis/Ast/Test/ClassesTests.cs +++ b/src/Analysis/Ast/Test/ClassesTests.cs @@ -634,5 +634,39 @@ def __init__(self): // Test run time: typically ~ 20 sec. sw.ElapsedMilliseconds.Should().BeLessThan(60000); } + + [TestMethod, Priority(0)] + public async Task NestedClasses() { + const string code = @" +class A: + class B: + def __init__(self): ... + + def __init__(self): ... + +x = A.B +ab = A.B() +"; + var analysis = await GetAnalysisAsync(code); + + analysis.Should().HaveVariable("x").OfType(BuiltinTypeId.Type); + var ab = analysis.Should().HaveVariable("ab").Which; + ab.Value.Should().BeAssignableTo() + .And.HaveType(typeof(IPythonClassType)); + + var c = ab.Value.GetPythonType(); + c.Should().NotBeNull(); + c.DeclaringType.Name.Should().Be("A"); + c.DeclaringType.Should().BeAssignableTo(); + } + + [TestMethod, Priority(0)] + public async Task MethodType() { + const string code = @" +x = type(object.__init__) +"; + var analysis = await GetAnalysisAsync(code); + analysis.Should().HaveVariable("x").OfType(BuiltinTypeId.Method); + } } } diff --git a/src/Analysis/Ast/Test/ConditionalsTests.cs b/src/Analysis/Ast/Test/ConditionalsTests.cs index 80faf453e..054142dd1 100644 --- a/src/Analysis/Ast/Test/ConditionalsTests.cs +++ b/src/Analysis/Ast/Test/ConditionalsTests.cs @@ -14,7 +14,6 @@ // permissions and limitations under the License. using System.Threading.Tasks; -using FluentAssertions; using Microsoft.Python.Analysis.Tests.FluentAssertions; using Microsoft.Python.Analysis.Types; using Microsoft.Python.Core.IO; @@ -76,15 +75,13 @@ public async Task SysPlatformWindows(bool isWindows) { const string code = @" if sys.platform == 'win32': x = 1 +else: + x = 'a' "; var platform = SubstitutePlatform(out var sm); platform.IsWindows.Returns(x => isWindows); var analysis = await GetAnalysisAsync(code, PythonVersions.LatestAvailable3X, sm); - if (isWindows) { - analysis.Should().HaveVariable("x").OfType(BuiltinTypeId.Int); - } else { - analysis.Should().NotHaveVariable("x"); - } + analysis.Should().HaveVariable("x").OfType(isWindows ? BuiltinTypeId.Int : BuiltinTypeId.Str); } [DataRow(false)] @@ -130,15 +127,45 @@ public async Task OsPathPosix(bool isWindows) { const string code = @" if 'posix' in _names: x = 1 +else: + x = 'a' "; var platform = SubstitutePlatform(out var sm); platform.IsWindows.Returns(x => isWindows); var analysis = await GetAnalysisAsync(code, PythonVersions.LatestAvailable2X, sm); - if (!isWindows) { - analysis.Should().HaveVariable("x").OfType(BuiltinTypeId.Int); - } else { - analysis.Should().NotHaveVariable("x"); - } + analysis.Should().HaveVariable("x").OfType(isWindows ? BuiltinTypeId.Str : BuiltinTypeId.Int); + } + + [DataRow(false)] + [DataRow(true)] + [DataTestMethod, Priority(0)] + public async Task FunctionByVersion(bool is3x) { + const string code = @" +if sys.version_info >= (3, 0): + def func(a): ... +else: + def func(a, b): ... +"; + var analysis = await GetAnalysisAsync(code, is3x ? PythonVersions.LatestAvailable3X : PythonVersions.LatestAvailable2X); + analysis.Should().HaveFunction("func") + .Which.Should().HaveSingleOverload() + .Which.Should().HaveParameters(is3x ? new[] { "a" } : new[] { "a", "b" }); + } + + [DataRow(false)] + [DataRow(true)] + [DataTestMethod, Priority(0)] + public async Task FunctionByVersionElif(bool is3x) { + const string code = @" +if sys.version_info >= (3, 0): + def func(a): ... +elif sys.version_info < (3, 0): + def func(a, b): ... +"; + var analysis = await GetAnalysisAsync(code, is3x ? PythonVersions.LatestAvailable3X : PythonVersions.LatestAvailable2X); + analysis.Should().HaveFunction("func") + .Which.Should().HaveSingleOverload() + .Which.Should().HaveParameters(is3x ? new[] { "a" } : new[] { "a", "b" }); } private IOSPlatform SubstitutePlatform(out IServiceManager sm) { diff --git a/src/Analysis/Ast/Test/FluentAssertions/MemberAssertions.cs b/src/Analysis/Ast/Test/FluentAssertions/MemberAssertions.cs index 6d18b1104..6658572e6 100644 --- a/src/Analysis/Ast/Test/FluentAssertions/MemberAssertions.cs +++ b/src/Analysis/Ast/Test/FluentAssertions/MemberAssertions.cs @@ -21,6 +21,7 @@ using FluentAssertions.Execution; using FluentAssertions.Primitives; using Microsoft.Python.Analysis.Types; +using Microsoft.Python.Analysis.Values; using static Microsoft.Python.Analysis.Tests.FluentAssertions.AssertionsUtilities; namespace Microsoft.Python.Analysis.Tests.FluentAssertions { @@ -70,7 +71,7 @@ public AndWhichConstraint HaveMember(string NotBeNull(); var t = Subject.GetPythonType(); - var mc = (IMemberContainer) t; + var mc = (IMemberContainer)t; Execute.Assertion.ForCondition(mc != null) .BecauseOf(because, reasonArgs) .FailWith($"Expected {GetName(t)} to be a member container{{reason}}."); @@ -88,9 +89,70 @@ public AndWhichConstraint HaveMember(string return new AndWhichConstraint(this, typedMember); } - public AndConstraint HaveSameMembersAs(IMember m) { - m.Should().BeAssignableTo(); - return HaveMembers(((IMemberContainer)m).GetMemberNames(), string.Empty); + public AndConstraint HaveSameMemberNamesAs(IMember member) { + member.Should().BeAssignableTo(); + return HaveMembers(((IMemberContainer)member).GetMemberNames(), string.Empty); + } + + public void HaveSameMembersAs(IMember other) { + other.Should().BeAssignableTo(); + var otherContainer = (IMemberContainer)other; + + var subjectType = Subject.GetPythonType(); + var subjectMemberNames = subjectType.GetMemberNames().ToArray(); + var otherMemberNames = otherContainer.GetMemberNames().ToArray(); + + var missingNames = otherMemberNames.Except(subjectMemberNames).ToArray(); + var extraNames = subjectMemberNames.Except(otherMemberNames).ToArray(); + + missingNames.Should().BeEmpty("Subject has missing names: ", missingNames); + extraNames.Should().BeEmpty("Subject has extra names: ", extraNames); + + foreach (var n in subjectMemberNames) { + var subjectMember = subjectType.GetMember(n); + var otherMember = otherContainer.GetMember(n); + var subjectMemberType = subjectMember.GetPythonType(); + var otherMemberType = otherMember.GetPythonType(); + + // PythonConstant, PythonUnicodeStrings... etc are mapped to instances. + if (subjectMember is IPythonInstance) { + otherMember.Should().BeAssignableTo(); + } + + subjectMemberType.MemberType.Should().Be(otherMemberType.MemberType); + + if (string.IsNullOrEmpty(subjectMemberType.Documentation)) { + otherMemberType.Documentation.Should().BeNullOrEmpty(); + } else { + subjectMemberType.Documentation.Should().Be(otherMemberType.Documentation); + } + + switch (subjectMemberType.MemberType) { + case PythonMemberType.Class: + // Restored collections (like instance of tuple) turn into classes + // rather than into collections with content since we don't track + // collection content in libraries. + subjectMemberType.QualifiedName.Should().Be(otherMemberType.QualifiedName); + break; + case PythonMemberType.Function: + case PythonMemberType.Method: + subjectMemberType.Should().BeAssignableTo(); + otherMemberType.Should().BeAssignableTo(); + if (subjectMemberType is IPythonFunctionType subjectFunction) { + var otherFunction = (IPythonFunctionType)otherMemberType; + subjectFunction.Should().HaveSameOverloadsAs(otherFunction); + } + + break; + case PythonMemberType.Property: + subjectMemberType.Should().BeAssignableTo(); + otherMemberType.Should().BeAssignableTo(); + break; + case PythonMemberType.Unknown: + subjectMemberType.IsUnknown().Should().BeTrue(); + break; + } + } } public AndConstraint HaveMembers(params string[] memberNames) diff --git a/src/Analysis/Ast/Test/FluentAssertions/PythonFunctionAssertions.cs b/src/Analysis/Ast/Test/FluentAssertions/PythonFunctionAssertions.cs index 5ba32fa27..f67644743 100644 --- a/src/Analysis/Ast/Test/FluentAssertions/PythonFunctionAssertions.cs +++ b/src/Analysis/Ast/Test/FluentAssertions/PythonFunctionAssertions.cs @@ -74,6 +74,17 @@ public AndWhichConstraint Hav return new AndWhichConstraint(this, overloads[index]); } + public void HaveSameOverloadsAs(IPythonFunctionType other, string because = "", params object[] reasonArgs) { + var overloads = Subject.Overloads.ToArray(); + Subject.Should().HaveOverloadCount(other.Overloads.Count); + + for (var i = 0; i < Subject.Overloads.Count; i++) { + var subjectOverload = Subject.Overloads[i]; + var otherOverload = other.Overloads[i]; + subjectOverload.Should().HaveSameParametersAs(otherOverload); + } + } + public AndWhichConstraint HaveParameterAt(int index, string because = "", params object[] reasonArgs) { var overloads = Subject.Overloads.ToArray(); Execute.Assertion.ForCondition(overloads.Length == 1) diff --git a/src/Analysis/Ast/Test/FluentAssertions/PythonFunctionOverloadAssertions.cs b/src/Analysis/Ast/Test/FluentAssertions/PythonFunctionOverloadAssertions.cs index 6ab5b0f8e..e79bcd533 100644 --- a/src/Analysis/Ast/Test/FluentAssertions/PythonFunctionOverloadAssertions.cs +++ b/src/Analysis/Ast/Test/FluentAssertions/PythonFunctionOverloadAssertions.cs @@ -102,6 +102,26 @@ public AndConstraint HaveParameters(IEnumerabl return new AndConstraint(this); } + public AndConstraint HaveSameParametersAs(IPythonFunctionOverload other, string because = "", params object[] reasonArgs) { + var parameters = Subject.Parameters.ToArray(); + var expected = other.Parameters.ToArray(); + + parameters.Should().HaveCount(other.Parameters.Count); + for (var j = 0; j < expected.Length; j++) { + var subjectParam = other.Parameters[j]; + var otherParam = other.Parameters[j]; + subjectParam.Name.Should().Be(otherParam.Name); + + if (subjectParam.Type == null) { + otherParam.Type.Should().BeNull(); + } else { + subjectParam.Type.Name.Should().Be(otherParam.Type.Name); + } + } + + return new AndConstraint(this); + } + public AndConstraint HaveNoParameters(string because = "", params object[] reasonArgs) => HaveParameters(Enumerable.Empty(), because, reasonArgs); diff --git a/src/Analysis/Ast/Test/FunctionTests.cs b/src/Analysis/Ast/Test/FunctionTests.cs index 7ebefdfdb..09a38c00e 100644 --- a/src/Analysis/Ast/Test/FunctionTests.cs +++ b/src/Analysis/Ast/Test/FunctionTests.cs @@ -567,6 +567,35 @@ def inner(): .And.HaveVariable("z").OfType(BuiltinTypeId.Int); } + [TestMethod, Priority(0)] + public async Task NestedMembers() { + const string code = @" +def outer(): + class innerClass(): ... + def innerFunc(): ... +"; + var analysis = await GetAnalysisAsync(code); + var outer = analysis.Should().HaveFunction("outer").Which as IPythonType; + outer.Should().HaveMember("innerClass"); + outer.Should().HaveMember("innerFunc"); + } + + [TestMethod, Priority(0)] + public async Task NestedPropertyMembers() { + const string code = @" +def outer(): + @property + def p(self): + class innerClass(): ... + def innerFunc(): ... +"; + var analysis = await GetAnalysisAsync(code); + var outer = analysis.Should().HaveFunction("outer").Which as IPythonType; + var p = outer.Should().HaveMember("p").Which as IPythonType; + p.Should().HaveMember("innerClass"); + p.Should().HaveMember("innerFunc"); + } + [TestMethod, Priority(0)] public async Task Deprecated() { const string code = @" diff --git a/src/Analysis/Ast/Test/LibraryTests.cs b/src/Analysis/Ast/Test/LibraryTests.cs index a26e53139..3a8935918 100644 --- a/src/Analysis/Ast/Test/LibraryTests.cs +++ b/src/Analysis/Ast/Test/LibraryTests.cs @@ -40,7 +40,7 @@ public async Task Random() { foreach (var fnName in new[] { @"seed", @"randrange", @"gauss" }) { analysis.Should().HaveVariable(fnName).Which - .Should().HaveType(BuiltinTypeId.Function) + .Should().HaveType(BuiltinTypeId.Method) .And.Value.GetPythonType().Documentation.Should().NotBeNullOrEmpty(); } } diff --git a/src/Analysis/Ast/Test/PepHintTests.cs b/src/Analysis/Ast/Test/PepHintTests.cs index 8964ddc7f..1cf706944 100644 --- a/src/Analysis/Ast/Test/PepHintTests.cs +++ b/src/Analysis/Ast/Test/PepHintTests.cs @@ -73,7 +73,7 @@ class Response: # truncated timedelta.IsUnknown().Should().BeFalse(); c.Should().HaveMember("elapsed") - .Which.Should().HaveSameMembersAs(timedelta); + .Which.Should().HaveSameMemberNamesAs(timedelta); } [TestMethod, Priority(0)] diff --git a/src/Analysis/Ast/Test/TypingTests.cs b/src/Analysis/Ast/Test/TypingTests.cs index f0856a743..606ecc3c5 100644 --- a/src/Analysis/Ast/Test/TypingTests.cs +++ b/src/Analysis/Ast/Test/TypingTests.cs @@ -265,9 +265,9 @@ from typing import AnyStr y = n2[0] "; var analysis = await GetAnalysisAsync(code); - analysis.Should().HaveVariable("n1").OfType("AnyStr") - .And.HaveVariable("x").OfType("AnyStr") - .And.HaveVariable("y").OfType("AnyStr"); + analysis.Should().HaveVariable("n1").OfType(BuiltinTypeId.Str) + .And.HaveVariable("x").OfType(BuiltinTypeId.Str) + .And.HaveVariable("y").OfType(BuiltinTypeId.Str); } [TestMethod, Priority(0)] diff --git a/src/Analysis/Core/Impl/Interpreter/InterpreterConfiguration.cs b/src/Analysis/Core/Impl/Interpreter/InterpreterConfiguration.cs index 1ed4f6331..208025789 100644 --- a/src/Analysis/Core/Impl/Interpreter/InterpreterConfiguration.cs +++ b/src/Analysis/Core/Impl/Interpreter/InterpreterConfiguration.cs @@ -15,21 +15,17 @@ using System; using System.Collections.Generic; -using System.Globalization; -using System.Linq; -using Microsoft.Python.Core; namespace Microsoft.Python.Analysis.Core.Interpreter { public sealed class InterpreterConfiguration : IEquatable { - private readonly string _description; - private string _fullDescription; - /// /// Constructs a new interpreter configuration based on the provided values. /// - public InterpreterConfiguration( - string id, - string description, + public InterpreterConfiguration(string interpreterPath = null, Version version = null) : + this(interpreterPath, string.Empty, null, null, default, version) { } + + // Tests only + internal InterpreterConfiguration( string interpreterPath = null, string pathVar = "", string libPath = null, @@ -37,8 +33,6 @@ public InterpreterConfiguration( InterpreterArchitecture architecture = default, Version version = null ) { - Id = id; - _description = description ?? string.Empty; InterpreterPath = interpreterPath; PathEnvironmentVariable = pathVar; Architecture = architecture ?? InterpreterArchitecture.Unknown; @@ -51,8 +45,6 @@ private static string Read(IReadOnlyDictionary d, string k) => d.TryGetValue(k, out var o) ? o as string : null; private InterpreterConfiguration(IReadOnlyDictionary properties) { - Id = Read(properties, nameof(Id)); - _description = Read(properties, nameof(Description)) ?? ""; InterpreterPath = Read(properties, nameof(InterpreterPath)); PathEnvironmentVariable = Read(properties, nameof(PathEnvironmentVariable)); LibraryPath = Read(properties, nameof(LibraryPath)); @@ -73,65 +65,6 @@ private InterpreterConfiguration(IReadOnlyDictionary properties) } } - public void WriteToDictionary(IDictionary properties) { - properties[nameof(Id)] = Id; - properties[nameof(Description)] = _description; - properties[nameof(InterpreterPath)] = InterpreterPath; - properties[nameof(PathEnvironmentVariable)] = PathEnvironmentVariable; - properties[nameof(LibraryPath)] = LibraryPath; - properties[nameof(Architecture)] = Architecture.ToString(); - if (Version != null) { - properties[nameof(Version)] = Version.ToString(); - } - properties[nameof(SearchPaths)] = SearchPaths.ToArray(); - } - - /// - /// Reconstructs an interpreter configuration from a dictionary. - /// - public static InterpreterConfiguration FromDictionary(IReadOnlyDictionary properties) - => new InterpreterConfiguration(properties); - - /// - /// Serializes an interpreter configuration to a dictionary. - /// - public IReadOnlyDictionary ToDictionary() { - var d = new Dictionary(); - WriteToDictionary(d); - return d; - } - - /// - /// Gets a unique and stable identifier for this interpreter. - /// - public string Id { get; } - - /// - /// Gets a friendly description of the interpreter - /// - public string Description => _fullDescription ?? _description; - - /// - /// Changes the description to be less likely to be - /// ambiguous with other interpreters. - /// - public void SwitchToFullDescription() { - var hasVersion = _description.Contains(Version.ToString()); - var hasArch = _description.IndexOf(Architecture.ToString(null, CultureInfo.CurrentCulture), StringComparison.CurrentCultureIgnoreCase) >= 0 || - _description.IndexOf(Architecture.ToString("x", CultureInfo.CurrentCulture), StringComparison.CurrentCultureIgnoreCase) >= 0; - - if (hasVersion && hasArch) { - // Regular description is sufficient - _fullDescription = null; - } else if (hasVersion) { - _fullDescription = "{0} ({1})".FormatUI(_description, Architecture); - } else if (hasArch) { - _fullDescription = "{0} ({1})".FormatUI(_description, Version); - } else { - _fullDescription = "{0} ({1}, {2})".FormatUI(_description, Version, Architecture); - } - } - /// /// Returns the path to the interpreter executable for launching Python /// applications. @@ -186,8 +119,7 @@ public bool Equals(InterpreterConfiguration other) { } var cmp = StringComparer.OrdinalIgnoreCase; - return string.Equals(Id, other.Id) && - cmp.Equals(Description, other.Description) && + return cmp.Equals(InterpreterPath, other.InterpreterPath) && cmp.Equals(PathEnvironmentVariable, other.PathEnvironmentVariable) && Architecture == other.Architecture && @@ -196,28 +128,13 @@ public bool Equals(InterpreterConfiguration other) { public override int GetHashCode() { var cmp = StringComparer.OrdinalIgnoreCase; - return Id.GetHashCode() ^ - cmp.GetHashCode(Description) ^ + return cmp.GetHashCode(InterpreterPath ?? "") ^ cmp.GetHashCode(PathEnvironmentVariable ?? "") ^ Architecture.GetHashCode() ^ Version.GetHashCode(); } - public override string ToString() => Description; - - /// - /// Attempts to update descriptions to be unique within the - /// provided sequence by adding information about the - /// interpreter that is missing from the default description. - /// - public static void DisambiguateDescriptions(IReadOnlyList configs) { - foreach (var c in configs) { - c._fullDescription = null; - } - foreach (var c in configs.GroupBy(i => i._description ?? "").Where(g => g.Count() > 1).SelectMany(g => g)) { - c.SwitchToFullDescription(); - } - } + public override string ToString() => InterpreterPath; } } diff --git a/src/Analysis/Core/Impl/Interpreter/PythonLibraryPath.cs b/src/Analysis/Core/Impl/Interpreter/PythonLibraryPath.cs index ae75f054c..5abcbb4ee 100644 --- a/src/Analysis/Core/Impl/Interpreter/PythonLibraryPath.cs +++ b/src/Analysis/Core/Impl/Interpreter/PythonLibraryPath.cs @@ -40,16 +40,9 @@ public PythonLibraryPath(string path, PythonLibraryPathType type = PythonLibrary ModulePrefix = modulePrefix ?? string.Empty; } - public PythonLibraryPath(string path, bool isStandardLibrary, string modulePrefix) : - this(path, isStandardLibrary ? PythonLibraryPathType.StdLib : PythonLibraryPathType.Unspecified, modulePrefix) { } - public string Path { get; } - public PythonLibraryPathType Type { get; } - - public string ModulePrefix { get; } = string.Empty; - - public bool IsStandardLibrary => Type == PythonLibraryPathType.StdLib; + public string ModulePrefix { get; } public override string ToString() { var type = string.Empty; @@ -69,9 +62,9 @@ public override string ToString() { return "{0}|{1}|{2}".FormatInvariant(Path, type, ModulePrefix); } - public static PythonLibraryPath Parse(string s) { + private static PythonLibraryPath Parse(string s) { if (string.IsNullOrEmpty(s)) { - throw new ArgumentNullException("source"); + throw new ArgumentNullException(nameof(s)); } var parts = s.Split(new[] { '|' }, 3); @@ -83,8 +76,7 @@ public static PythonLibraryPath Parse(string s) { var ty = parts[1]; var prefix = parts[2]; - PythonLibraryPathType type = PythonLibraryPathType.Unspecified; - + var type = PythonLibraryPathType.Unspecified; switch (ty) { case "stdlib": type = PythonLibraryPathType.StdLib; @@ -106,8 +98,7 @@ public static PythonLibraryPath Parse(string s) { /// /// Root of the standard library. /// A list of search paths for the interpreter. - /// New in 2.2, moved in 3.3 - public static List GetDefaultSearchPaths(string library) { + private static List GetDefaultSearchPaths(string library) { var result = new List(); if (!Directory.Exists(library)) { return result; @@ -174,19 +165,15 @@ public static string GetSitePackagesPath(string standardLibraryPath) public static async Task> GetSearchPathsFromInterpreterAsync(string interpreter, IFileSystem fs, IProcessServices ps, CancellationToken cancellationToken = default) { // sys.path will include the working directory, so we make an empty // path that we can filter out later - var tempWorkingDir = IOPath.Combine(IOPath.GetTempPath(), IOPath.GetRandomFileName()); - fs.CreateDirectory(tempWorkingDir); - if (!InstallPath.TryGetFile("get_search_paths.py", out var srcGetSearchPaths)) { + if (!InstallPath.TryGetFile("get_search_paths.py", out var getSearchPathScript)) { return new List(); } - var getSearchPaths = IOPath.Combine(tempWorkingDir, PathUtils.GetFileName(srcGetSearchPaths)); - File.Copy(srcGetSearchPaths, getSearchPaths); var startInfo = new ProcessStartInfo( interpreter, - new[] { "-S", "-E", getSearchPaths }.AsQuotedArguments() + new[] { "-S", "-E", getSearchPathScript }.AsQuotedArguments() ) { - WorkingDirectory = tempWorkingDir, + WorkingDirectory = IOPath.GetDirectoryName(getSearchPathScript), UseShellExecute = false, ErrorDialog = false, CreateNoWindow = true, @@ -194,17 +181,11 @@ public static async Task> GetSearchPathsFromInterpreterA RedirectStandardOutput = true }; - try { - var output = await ps.ExecuteAndCaptureOutputAsync(startInfo, cancellationToken); - return output.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).Select(s => { + var output = await ps.ExecuteAndCaptureOutputAsync(startInfo, cancellationToken); + return output.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries) + .Skip(1).Select(s => { try { - var p = Parse(s); - - if (PathUtils.PathStartsWith(p.Path, tempWorkingDir)) { - return null; - } - - return p; + return Parse(s); } catch (ArgumentException) { Debug.Fail("Invalid search path: " + (s ?? "")); return null; @@ -212,10 +193,8 @@ public static async Task> GetSearchPathsFromInterpreterA Debug.Fail("Invalid format for search path: " + s); return null; } - }).Where(p => p != null).ToList(); - } finally { - fs.DeleteDirectory(tempWorkingDir, true); - } + }) + .Where(p => p != null).ToList(); } public static (IReadOnlyList interpreterPaths, IReadOnlyList userPaths) ClassifyPaths( @@ -304,7 +283,6 @@ public bool Equals(PythonLibraryPath other) { } public static bool operator ==(PythonLibraryPath left, PythonLibraryPath right) => left?.Equals(right) ?? right is null; - public static bool operator !=(PythonLibraryPath left, PythonLibraryPath right) => !(left?.Equals(right) ?? right is null); } } diff --git a/src/Analysis/Core/Impl/Properties/AssemblyInfo.cs b/src/Analysis/Core/Impl/Properties/AssemblyInfo.cs index 33b24b71a..cd223fd12 100644 --- a/src/Analysis/Core/Impl/Properties/AssemblyInfo.cs +++ b/src/Analysis/Core/Impl/Properties/AssemblyInfo.cs @@ -17,4 +17,5 @@ [assembly: InternalsVisibleTo("Microsoft.Python.Analysis.Engine, PublicKey=002400000480000094000000060200000024000052534131000400000100010007d1fa57c4aed9f0a32e84aa0faefd0de9e8fd6aec8f87fb03766c834c99921eb23be79ad9d5dcc1dd9ad236132102900b723cf980957fc4e177108fc607774f29e8320e92ea05ece4e821c0a5efe8f1645c4c0c93c1ab99285d622caa652c1dfad63d745d6f2de5f17e5eaf0fc4963d261c8a12436518206dc093344d5ad293")] [assembly: InternalsVisibleTo("Microsoft.Python.Analysis, PublicKey=002400000480000094000000060200000024000052534131000400000100010007d1fa57c4aed9f0a32e84aa0faefd0de9e8fd6aec8f87fb03766c834c99921eb23be79ad9d5dcc1dd9ad236132102900b723cf980957fc4e177108fc607774f29e8320e92ea05ece4e821c0a5efe8f1645c4c0c93c1ab99285d622caa652c1dfad63d745d6f2de5f17e5eaf0fc4963d261c8a12436518206dc093344d5ad293")] +[assembly: InternalsVisibleTo("Microsoft.Python.Parsing.Tests, PublicKey=002400000480000094000000060200000024000052534131000400000100010007d1fa57c4aed9f0a32e84aa0faefd0de9e8fd6aec8f87fb03766c834c99921eb23be79ad9d5dcc1dd9ad236132102900b723cf980957fc4e177108fc607774f29e8320e92ea05ece4e821c0a5efe8f1645c4c0c93c1ab99285d622caa652c1dfad63d745d6f2de5f17e5eaf0fc4963d261c8a12436518206dc093344d5ad293")] [assembly: InternalsVisibleTo("Microsoft.Python.Analysis.Engine.Tests, PublicKey=002400000480000094000000060200000024000052534131000400000100010007d1fa57c4aed9f0a32e84aa0faefd0de9e8fd6aec8f87fb03766c834c99921eb23be79ad9d5dcc1dd9ad236132102900b723cf980957fc4e177108fc607774f29e8320e92ea05ece4e821c0a5efe8f1645c4c0c93c1ab99285d622caa652c1dfad63d745d6f2de5f17e5eaf0fc4963d261c8a12436518206dc093344d5ad293")] diff --git a/src/Caching/Impl/Factories/ClassFactory.cs b/src/Caching/Impl/Factories/ClassFactory.cs index 0e790279e..f0c9be0f6 100644 --- a/src/Caching/Impl/Factories/ClassFactory.cs +++ b/src/Caching/Impl/Factories/ClassFactory.cs @@ -26,7 +26,7 @@ public ClassFactory(IEnumerable classes, ModuleFactory mf) : base(classes, mf) { } - protected override PythonClassType CreateMember(ClassModel cm, IPythonType declaringType) + public override PythonClassType CreateMember(ClassModel cm, IPythonType declaringType) => new PythonClassType(cm.Name, new Location(ModuleFactory.Module, cm.IndexSpan.ToSpan())); protected override void CreateMemberParts(ClassModel cm, PythonClassType cls) { @@ -34,6 +34,7 @@ protected override void CreateMemberParts(ClassModel cm, PythonClassType cls) { var is3x = ModuleFactory.Module.Interpreter.LanguageVersion.Is3x(); var bases = cm.Bases.Select(b => is3x && b == "object" ? null : TryCreate(b)).ExcludeDefault().ToArray(); cls.SetBases(bases); + cls.SetDocumentation(cm.Documentation); foreach (var f in cm.Methods) { cls.AddMember(f.Name, ModuleFactory.FunctionFactory.Construct(f, cls, false), false); @@ -44,7 +45,10 @@ protected override void CreateMemberParts(ClassModel cm, PythonClassType cls) { foreach (var c in cm.InnerClasses) { cls.AddMember(c.Name, Construct(c, cls, false), false); } - // TODO: fields. Bypass variable cache! + foreach(var vm in cm.Fields) { + var v = ModuleFactory.VariableFactory.Construct(vm, cls, false); + cls.AddMember(v.Name, v, false); + } } } } diff --git a/src/Caching/Impl/Factories/FactoryBase.cs b/src/Caching/Impl/Factories/FactoryBase.cs index 9456eade4..2120879a2 100644 --- a/src/Caching/Impl/Factories/FactoryBase.cs +++ b/src/Caching/Impl/Factories/FactoryBase.cs @@ -20,6 +20,10 @@ using Microsoft.Python.Analysis.Types; namespace Microsoft.Python.Analysis.Caching.Factories { + /// + /// Represents base factory that implements creation of a type + /// from its model (persistent form). + /// internal abstract class FactoryBase : IDisposable where TModel : MemberModel where TMember : IMember { @@ -41,6 +45,9 @@ protected FactoryBase(IEnumerable models, ModuleFactory mf) { public TMember TryCreate(string name, IPythonType declaringType = null) => _data.TryGetValue(name, out var data) ? Construct(data.Model, declaringType) : default; + /// + /// Constructs member from its persistent model. + /// public TMember Construct(TModel cm, IPythonType declaringType = null, bool cached = true) { TMember m; @@ -60,7 +67,7 @@ public TMember Construct(TModel cm, IPythonType declaringType = null, bool cache public virtual void Dispose() => _data.Clear(); - protected abstract TMember CreateMember(TModel model, IPythonType declaringType); + public abstract TMember CreateMember(TModel model, IPythonType declaringType); protected virtual void CreateMemberParts(TModel model, TMember member) { } } } diff --git a/src/Caching/Impl/Factories/FunctionFactory.cs b/src/Caching/Impl/Factories/FunctionFactory.cs index b4cdb25bc..07503bedb 100644 --- a/src/Caching/Impl/Factories/FunctionFactory.cs +++ b/src/Caching/Impl/Factories/FunctionFactory.cs @@ -24,16 +24,32 @@ public FunctionFactory(IEnumerable classes, ModuleFactory mf) : base(classes, mf) { } - protected override IPythonFunctionType CreateMember(FunctionModel fm, IPythonType declaringType) { - var f = new PythonFunctionType(fm.Name, new Location(ModuleFactory.Module, fm.IndexSpan.ToSpan()), declaringType, fm.Documentation); + public override IPythonFunctionType CreateMember(FunctionModel fm, IPythonType declaringType) { + var ft = new PythonFunctionType(fm.Name, new Location(ModuleFactory.Module, fm.IndexSpan.ToSpan()), declaringType, fm.Documentation); + foreach (var om in fm.Overloads) { var o = new PythonFunctionOverload(fm.Name, new Location(ModuleFactory.Module, fm.IndexSpan.ToSpan())); o.SetDocumentation(fm.Documentation); o.SetReturnValue(ModuleFactory.ConstructMember(om.ReturnType), true); o.SetParameters(om.Parameters.Select(ConstructParameter).ToArray()); - f.AddOverload(o); + ft.AddOverload(o); + } + + foreach(var model in fm.Functions) { + var f = CreateMember(model, ft); + if (f != null) { + ft.AddMember(f.Name, f, overwrite: true); + } } - return f; + + foreach (var model in fm.Classes) { + var c = ModuleFactory.ClassFactory.CreateMember(model, ft); + if (c != null) { + ft.AddMember(c.Name, c, overwrite: true); + } + } + + return ft; } private IParameterInfo ConstructParameter(ParameterModel pm) diff --git a/src/Caching/Impl/Factories/ModuleFactory.cs b/src/Caching/Impl/Factories/ModuleFactory.cs index a2ba630c3..b82b7a297 100644 --- a/src/Caching/Impl/Factories/ModuleFactory.cs +++ b/src/Caching/Impl/Factories/ModuleFactory.cs @@ -18,15 +18,19 @@ using System.Diagnostics; using System.Linq; using Microsoft.Python.Analysis.Caching.Models; +using Microsoft.Python.Analysis.Modules; using Microsoft.Python.Analysis.Specializations.Typing; using Microsoft.Python.Analysis.Specializations.Typing.Types; using Microsoft.Python.Analysis.Types; using Microsoft.Python.Analysis.Utilities; using Microsoft.Python.Analysis.Values; +using Microsoft.Python.Core; namespace Microsoft.Python.Analysis.Caching.Factories { internal sealed class ModuleFactory : IDisposable { - private static readonly ReentrancyGuard _processing = new ReentrancyGuard(); + // TODO: better resolve circular references. + private readonly ReentrancyGuard _typeReentrancy = new ReentrancyGuard(); + private readonly ReentrancyGuard _moduleReentrancy = new ReentrancyGuard(); public IPythonModule Module { get; } public ClassFactory ClassFactory { get; } @@ -53,49 +57,121 @@ public void Dispose() { public IPythonType ConstructType(string qualifiedName) => ConstructMember(qualifiedName)?.GetPythonType(); public IMember ConstructMember(string qualifiedName) { - if (!TypeNames.DeconstructQualifiedName(qualifiedName, out var moduleName, out var memberNames, out var isInstance)) { + // Determine module name, member chain and if this is an instance. + if (!TypeNames.DeconstructQualifiedName(qualifiedName, out var parts)) { return null; } // TODO: better resolve circular references. - if (!_processing.Push(qualifiedName) || memberNames.Count < 2) { + if (!_typeReentrancy.Push(qualifiedName)) { return null; } try { // See if member is a module first. - var module = moduleName == Module.Name ? Module : Module.Interpreter.ModuleResolution.GetOrLoadModule(moduleName); + var module = GetModule(parts); if (module == null) { return null; } - var member = moduleName == Module.Name - ? GetMemberFromThisModule(memberNames) - : GetMemberFromModule(module, memberNames); + if (parts.ObjectType == ObjectType.NamedTuple) { + return ConstructNamedTuple(parts.MemberNames[0], module); + } + + var member = parts.ModuleName == Module.Name + ? GetMemberFromThisModule(parts.MemberNames) + : GetMemberFromModule(module, parts.MemberNames); - if (!isInstance) { + if (parts.ObjectType != ObjectType.Instance) { return member; } var t = member.GetPythonType() ?? module.Interpreter.UnknownType; return new PythonInstance(t); } finally { - _processing.Pop(); + _typeReentrancy.Pop(); } } - private IMember GetMemberFromModule(IPythonModule module, IReadOnlyList memberNames) { + private IPythonModule GetModule(QualifiedNameParts parts) { + if (parts.ModuleName == Module.Name) { + return Module; + } + if (!_moduleReentrancy.Push(parts.ModuleName)) { + return null; + } + + try { + // Here we do not call GetOrLoad since modules references here must + // either be loaded already since they were required to create + // persistent state from analysis. Also, occasionally types come + // from the stub and the main module was never loaded. This, for example, + // happens with io which has member with mmap type coming from mmap + // stub rather than the primary mmap module. + var m = Module.Interpreter.ModuleResolution.GetImportedModule(parts.ModuleName); + // Try stub-only case (ex _importlib_modulespec). + m = m ?? Module.Interpreter.TypeshedResolution.GetImportedModule(parts.ModuleName); + if (m != null) { + return parts.ObjectType == ObjectType.VariableModule ? new PythonVariableModule(m) : m; + } + + return null; + } finally { + _moduleReentrancy.Pop(); + } + } + + private IMember GetMemberFromModule(IPythonModule module, IReadOnlyList memberNames) + => memberNames.Count == 0 ? module : GetMember(module, memberNames); + + private IMember GetBuiltinMember(IBuiltinsPythonModule builtins, string memberName) { + if (memberName.StartsWithOrdinal("__")) { + memberName = memberName.Substring(2, memberName.Length - 4); + } + + switch (memberName) { + case "NoneType": + return builtins.Interpreter.GetBuiltinType(BuiltinTypeId.NoneType); + case "Unknown": + return builtins.Interpreter.UnknownType; + } + return builtins.GetMember(memberName); + } + + private IMember GetMemberFromThisModule(IReadOnlyList memberNames) { if (memberNames.Count == 0) { return null; } - IMember member = module; - foreach (var memberName in memberNames) { - var typeArgs = GetTypeArguments(memberName, out _); + var name = memberNames[0]; + var root = ClassFactory.TryCreate(name) + ?? (FunctionFactory.TryCreate(name) + ?? (IMember)VariableFactory.TryCreate(name)); + + return GetMember(root, memberNames.Skip(1)); + } + + private IMember GetMember(IMember root, IEnumerable memberNames) { + IMember member = root; + foreach (var n in memberNames) { + var memberName = n; + // Check if name has type arguments such as Union[int, str] + // Note that types can be nested like Union[int, Union[A, B]] + var typeArgs = GetTypeArguments(memberName, out var typeName); + if (typeArgs.Count > 0) { + memberName = typeName; + } var mc = member as IMemberContainer; Debug.Assert(mc != null); - member = mc?.GetMember(memberName); + + if (mc is IBuiltinsPythonModule builtins) { + // Builtins require special handling since there may be 'hidden' names + // like __NoneType__ which need to be mapped to visible types. + member = GetBuiltinMember(builtins, memberName) ?? builtins.Interpreter.UnknownType; + } else { + member = mc?.GetMember(memberName); + } if (member == null) { Debug.Assert(member != null); @@ -110,18 +186,6 @@ private IMember GetMemberFromModule(IPythonModule module, IReadOnlyList return member; } - private IMember GetMemberFromThisModule(IReadOnlyList memberNames) { - if (memberNames.Count == 0) { - return null; - } - - // TODO: nested classes, etc (traverse parts and recurse). - var name = memberNames[0]; - return ClassFactory.TryCreate(name) - ?? (FunctionFactory.TryCreate(name) - ?? (IMember)VariableFactory.TryCreate(name)); - } - private IReadOnlyList GetTypeArguments(string memberName, out string typeName) { typeName = null; // TODO: better handle generics. @@ -134,7 +198,9 @@ private IReadOnlyList GetTypeArguments(string memberName, out strin var closeBracket = memberName.LastIndexOf(']'); if (closeBracket > 0) { var argumentString = memberName.Substring(openBracket + 1, closeBracket - openBracket - 1); - var arguments = argumentString.Split(',').Select(s => s.Trim()).ToArray(); + // Extract type names from argument string. Note that types themselves + // can have arguments: Union[int, Union[int, Union[str, bool]], ...]. + var arguments = TypeNames.GetTypeNames(argumentString, ','); foreach (var a in arguments) { var t = ConstructType(a); // TODO: better handle generics type definitions from TypeVar. @@ -147,5 +213,32 @@ private IReadOnlyList GetTypeArguments(string memberName, out strin } return typeArgs; } + + private ITypingNamedTupleType ConstructNamedTuple(string tupleString, IPythonModule module) { + // tuple_name(name: type, name: type, ...) + // time_result(columns: int, lines: int) + var openBraceIndex = tupleString.IndexOf('('); + var closeBraceIndex = tupleString.IndexOf(')'); + var name = tupleString.Substring(0, openBraceIndex); + var argString = tupleString.Substring(openBraceIndex + 1, closeBraceIndex - openBraceIndex - 1); + + var itemNames = new List(); + var itemTypes = new List(); + var start = 0; + + for (var i = 0; i < argString.Length; i++) { + var ch = argString[i]; + if (ch == ':') { + itemNames.Add(argString.Substring(start, i - start).Trim()); + i++; + var paramType = TypeNames.GetTypeName(argString, ref i, ','); + var t = ConstructType(paramType); + itemTypes.Add(t ?? module.Interpreter.UnknownType); + start = i + 1; + } + } + + return new NamedTupleType(name, itemNames, itemTypes, module, module.Interpreter); + } } } diff --git a/src/Caching/Impl/Factories/VariableFactory.cs b/src/Caching/Impl/Factories/VariableFactory.cs index 45a497970..ad624d183 100644 --- a/src/Caching/Impl/Factories/VariableFactory.cs +++ b/src/Caching/Impl/Factories/VariableFactory.cs @@ -24,9 +24,9 @@ public VariableFactory(IEnumerable models, ModuleFactory mf) : base(models, mf) { } - protected override IVariable CreateMember(VariableModel vm, IPythonType declaringType) { - var m = ModuleFactory.ConstructMember(vm.Value); - return new Variable(vm.Name, m, VariableSource.Declaration, new Location(ModuleFactory.Module, vm.IndexSpan.ToSpan())); + public override IVariable CreateMember(VariableModel vm, IPythonType declaringType) { + var m = ModuleFactory.ConstructMember(vm.Value) ?? ModuleFactory.Module.Interpreter.UnknownType; + return new Variable(vm.Name, m, VariableSource.Declaration, new Location(ModuleFactory.Module, vm.IndexSpan?.ToSpan() ?? default)); } } } diff --git a/src/Caching/Impl/Models/ClassModel.cs b/src/Caching/Impl/Models/ClassModel.cs index 9787f7e61..2b44c1472 100644 --- a/src/Caching/Impl/Models/ClassModel.cs +++ b/src/Caching/Impl/Models/ClassModel.cs @@ -22,8 +22,8 @@ using Microsoft.Python.Core; namespace Microsoft.Python.Analysis.Caching.Models { - [DebuggerDisplay("c:{Name}")] - internal sealed class ClassModel: MemberModel { + [DebuggerDisplay("cls:{Name}")] + internal sealed class ClassModel : MemberModel { public string Documentation { get; set; } public string[] Bases { get; set; } public FunctionModel[] Methods { get; set; } @@ -49,7 +49,7 @@ private ClassModel(IPythonClassType cls) { var m = cls.GetMember(name); // Only take members from this class, skip members from bases. - if (m is IPythonClassMember cm && !cls.Equals(cm.DeclaringType)) { + if (m is IPythonClassMember cm && cls.QualifiedName != cm.DeclaringType?.QualifiedName) { continue; } @@ -65,6 +65,8 @@ private ClassModel(IPythonClassType cls) { } innerClasses.Add(FromType(ct)); break; + case IPythonFunctionType ft when ft.IsLambda(): + break; case IPythonFunctionType ft when ft.Name == name: methods.Add(FunctionModel.FromType(ft)); break; @@ -88,7 +90,7 @@ private ClassModel(IPythonClassType cls) { IndexSpan = cls.Location.IndexSpan.ToModel(); Documentation = cls.Documentation; - Bases = cls.Bases.OfType().Select(t => t.GetQualifiedName()).ToArray(); + Bases = cls.Bases.OfType().Select(t => t.GetPersistentQualifiedName()).ToArray(); Methods = methods.ToArray(); Properties = properties.ToArray(); Fields = fields.ToArray(); diff --git a/src/Caching/Impl/Models/FunctionModel.cs b/src/Caching/Impl/Models/FunctionModel.cs index 9cebb7005..4c601b792 100644 --- a/src/Caching/Impl/Models/FunctionModel.cs +++ b/src/Caching/Impl/Models/FunctionModel.cs @@ -13,9 +13,12 @@ // See the Apache Version 2.0 License for specific language governing // permissions and limitations under the License. +using System.Collections.Generic; using System.Diagnostics; using System.Linq; using Microsoft.Python.Analysis.Types; +using Microsoft.Python.Analysis.Utilities; +using Microsoft.Python.Analysis.Values; using Microsoft.Python.Core; namespace Microsoft.Python.Analysis.Caching.Models { @@ -24,30 +27,62 @@ internal sealed class FunctionModel: MemberModel { public string Documentation { get; set; } public OverloadModel[] Overloads { get; set; } public FunctionAttributes Attributes { get; set; } - public string[] Classes { get; set; } - public string[] Functions { get; set; } - - public static FunctionModel FromType(IPythonFunctionType ft) { - return new FunctionModel { - Id = ft.Name.GetStableHash(), - Name = ft.Name, - IndexSpan = ft.Location.IndexSpan.ToModel(), - Documentation = ft.Documentation, - Overloads = ft.Overloads.Select(FromOverload).ToArray() - // TODO: attributes, inner functions and inner classes. - }; - } + public ClassModel[] Classes { get; set; } + public FunctionModel[] Functions { get; set; } + + private readonly ReentrancyGuard _processing = new ReentrancyGuard(); + + public static FunctionModel FromType(IPythonFunctionType ft) => new FunctionModel(ft); private static OverloadModel FromOverload(IPythonFunctionOverload o) { return new OverloadModel { Parameters = o.Parameters.Select(p => new ParameterModel { Name = p.Name, - Type = p.Type.GetQualifiedName(), + Type = p.Type.GetPersistentQualifiedName(), Kind = p.Kind, - DefaultValue = p.DefaultValue.GetQualifiedName(), + DefaultValue = p.DefaultValue.GetPersistentQualifiedName(), }).ToArray(), - ReturnType = o.StaticReturnValue.GetQualifiedName() + ReturnType = o.StaticReturnValue.GetPersistentQualifiedName() }; } + + public FunctionModel() { } // For de-serializer from JSON + + private FunctionModel(IPythonFunctionType func) { + var functions = new List(); + var classes = new List(); + + foreach (var name in func.GetMemberNames()) { + var m = func.GetMember(name); + + // Only take members from this class, skip members from bases. + if (!_processing.Push(m)) { + continue; + } + + try { + switch (m) { + case IPythonFunctionType ft when ft.IsLambda(): + break; + case IPythonFunctionType ft: + functions.Add(FromType(ft)); + break; + case IPythonClassType cls: + classes.Add(ClassModel.FromType(cls)); + break; + } + } finally { + _processing.Pop(); + } + } + + Id = func.Name.GetStableHash(); + Name = func.Name; + IndexSpan = func.Location.IndexSpan.ToModel(); + Documentation = func.Documentation; + Overloads = func.Overloads.Select(FromOverload).ToArray(); + Classes = classes.ToArray(); + Functions = functions.ToArray(); + } } } diff --git a/src/Caching/Impl/Models/ModuleModel.cs b/src/Caching/Impl/Models/ModuleModel.cs index 46d3dee73..883c774d8 100644 --- a/src/Caching/Impl/Models/ModuleModel.cs +++ b/src/Caching/Impl/Models/ModuleModel.cs @@ -15,10 +15,10 @@ using System.Collections.Generic; using System.Linq; +using Microsoft.Python.Analysis.Specializations.Typing; using Microsoft.Python.Analysis.Types; using Microsoft.Python.Analysis.Values; using Microsoft.Python.Core; -using Microsoft.Python.Parsing; namespace Microsoft.Python.Analysis.Caching.Models { internal sealed class ModuleModel : MemberModel { @@ -55,34 +55,42 @@ public static ModuleModel FromAnalysis(IDocumentAnalysis analysis, IServiceConta var exportedNames = new HashSet(analysis.Document.GetMemberNames()); foreach (var v in analysis.GlobalScope.Variables .Where(v => exportedNames.Contains(v.Name) || v.Source == VariableSource.Declaration || v.Source == VariableSource.Builtin)) { - // Create type model before variable since variable needs it. - string typeName = null; switch (v.Value) { - case IPythonFunctionType ft - when ft.DeclaringModule.Equals(analysis.Document) || ft.DeclaringModule.Equals(analysis.Document.Stub): - if (!functions.ContainsKey(ft.Name)) { - typeName = ft.Name; - functions[ft.Name] = FunctionModel.FromType(ft); + case IPythonFunctionType ft when ft.IsLambda(): + // No need to persist lambdas. + continue; + case IPythonFunctionType ft when v.Name != ft.Name: + // Variable assigned to type info of the function like + // def func(): ... + // x = type(func) + break; + case IPythonFunctionType ft: + var fm = GetFunctionModel(analysis, v, ft); + if (fm != null && !functions.ContainsKey(ft.Name)) { + functions[ft.Name] = fm; + continue; } - + break; + case IPythonClassType cls when v.Name != cls.Name: + // Variable assigned to type info of the class. break; case IPythonClassType cls when cls.DeclaringModule.Equals(analysis.Document) || cls.DeclaringModule.Equals(analysis.Document.Stub): if (!classes.ContainsKey(cls.Name)) { - typeName = cls.Name; classes[cls.Name] = ClassModel.FromType(cls); + continue; } break; } // Do not re-declare classes and functions as variables in the model. - if (typeName == null && !variables.ContainsKey(v.Name)) { + if (!variables.ContainsKey(v.Name)) { variables[v.Name] = VariableModel.FromVariable(v); } } - var uniqueId = analysis.Document.GetUniqieId(services); + var uniqueId = analysis.Document.GetUniqueId(services); return new ModuleModel { Id = uniqueId.GetStableHash(), UniqueId = uniqueId, @@ -98,5 +106,21 @@ when cls.DeclaringModule.Equals(analysis.Document) || cls.DeclaringModule.Equals FileSize = analysis.Ast.EndIndex }; } + + private static FunctionModel GetFunctionModel(IDocumentAnalysis analysis, IVariable v, IPythonFunctionType f) { + if (v.Source == VariableSource.Import && !f.DeclaringModule.Equals(analysis.Document) && !f.DeclaringModule.Equals(analysis.Document.Stub)) { + // It may be that the function is from a child module via import. + // For example, a number of functions in 'os' are imported from 'nt' on Windows via + // star import. Their stubs, however, come from 'os' stub. The function then have declaring + // module as 'nt' rather than 'os' and 'nt' does not have a stub. In this case use function + // model like if function was declared in 'os'. + return FunctionModel.FromType(f); + } + + if (f.DeclaringModule.Equals(analysis.Document) || f.DeclaringModule.Equals(analysis.Document.Stub)) { + return FunctionModel.FromType(f); + } + return null; + } } } diff --git a/src/Caching/Impl/Models/PropertyModel.cs b/src/Caching/Impl/Models/PropertyModel.cs index 2937cecbd..91cb0feef 100644 --- a/src/Caching/Impl/Models/PropertyModel.cs +++ b/src/Caching/Impl/Models/PropertyModel.cs @@ -28,7 +28,7 @@ public static PropertyModel FromType(IPythonPropertyType prop) { Name = prop.Name, IndexSpan = prop.Location.IndexSpan.ToModel(), Documentation = prop.Documentation, - ReturnType = prop.ReturnType.GetQualifiedName(), + ReturnType = prop.ReturnType.GetPersistentQualifiedName() // TODO: attributes. }; } diff --git a/src/Caching/Impl/Models/VariableModel.cs b/src/Caching/Impl/Models/VariableModel.cs index c44b3eb77..e6467d312 100644 --- a/src/Caching/Impl/Models/VariableModel.cs +++ b/src/Caching/Impl/Models/VariableModel.cs @@ -27,20 +27,20 @@ internal sealed class VariableModel: MemberModel { Id = v.Name.GetStableHash(), Name = v.Name, IndexSpan = v.Location.IndexSpan.ToModel(), - Value = v.Value.GetQualifiedName() + Value = v.Value.GetPersistentQualifiedName() }; public static VariableModel FromInstance(string name, IPythonInstance inst) => new VariableModel { Id = name.GetStableHash(), Name = name, - Value = inst.GetQualifiedName() + Value = inst.GetPersistentQualifiedName() }; public static VariableModel FromType(string name, IPythonType t) => new VariableModel { Id = name.GetStableHash(), Name = name, IndexSpan = t.Location.IndexSpan.ToModel(), - Value = t.QualifiedName + Value = t.GetPersistentQualifiedName() }; } } diff --git a/src/Caching/Impl/ModuleDatabase.cs b/src/Caching/Impl/ModuleDatabase.cs index 85c82e9f6..3c7e2779e 100644 --- a/src/Caching/Impl/ModuleDatabase.cs +++ b/src/Caching/Impl/ModuleDatabase.cs @@ -146,7 +146,7 @@ private void StoreModuleAnalysis(IDocumentAnalysis analysis, CancellationToken c /// private string FindDatabaseFile(string moduleName, string filePath) { var interpreter = _services.GetService(); - var uniqueId = ModuleUniqueId.GetUniqieId(moduleName, filePath, ModuleType.Specialized, _services); + var uniqueId = ModuleUniqueId.GetUniqueId(moduleName, filePath, ModuleType.Specialized, _services); if (string.IsNullOrEmpty(uniqueId)) { return null; } diff --git a/src/Caching/Impl/ModuleUniqueId.cs b/src/Caching/Impl/ModuleUniqueId.cs index 7c5e7524d..879211599 100644 --- a/src/Caching/Impl/ModuleUniqueId.cs +++ b/src/Caching/Impl/ModuleUniqueId.cs @@ -14,9 +14,9 @@ // permissions and limitations under the License. using System; +using System.Collections.Generic; using System.IO; using System.Linq; -using System.Security.Cryptography; using Microsoft.Python.Analysis.Core.Interpreter; using Microsoft.Python.Analysis.Modules; using Microsoft.Python.Analysis.Types; @@ -25,10 +25,10 @@ namespace Microsoft.Python.Analysis.Caching { internal static class ModuleUniqueId { - public static string GetUniqieId(this IPythonModule module, IServiceContainer services) - => GetUniqieId(module.Name, module.FilePath, module.ModuleType, services); + public static string GetUniqueId(this IPythonModule module, IServiceContainer services) + => GetUniqueId(module.Name, module.FilePath, module.ModuleType, services); - public static string GetUniqieId(string moduleName, string filePath, ModuleType moduleType, IServiceContainer services) { + public static string GetUniqueId(string moduleName, string filePath, ModuleType moduleType, IServiceContainer services) { var interpreter = services.GetService(); var fs = services.GetService(); @@ -37,31 +37,38 @@ public static string GetUniqieId(string moduleName, string filePath, ModuleType return $"{moduleName}"; } - var config = interpreter.Configuration; - var standardLibraryPath = PythonLibraryPath.GetStandardLibraryPath(config); - var sitePackagesPath = PythonLibraryPath.GetSitePackagesPath(config); + var modulePathType = GetModulePathType(filePath, interpreter.ModuleResolution.LibraryPaths, fs); - if (!string.IsNullOrEmpty(filePath) && fs.IsPathUnderRoot(sitePackagesPath, filePath)) { - // If module is in site-packages and is versioned, then unique id = name + version + interpreter version. - // Example: 'requests' and 'requests-2.21.0.dist-info'. - var moduleFolder = Path.GetDirectoryName(Path.GetDirectoryName(filePath)); + if (!string.IsNullOrEmpty(filePath) && modulePathType == PythonLibraryPathType.Site) { + // Module can be a submodule of a versioned package. In this case we want to use + // version of the enclosing package so we have to look up the chain of folders. + var moduleRootName = moduleName.Split('.')[0]; + var moduleFilesFolder = Path.GetDirectoryName(filePath); + var installationFolder = Path.GetDirectoryName(moduleFilesFolder); - // TODO: for egg (https://github.com/microsoft/python-language-server/issues/196), consider *.egg-info - var folders = fs - .GetFileSystemEntries(moduleFolder, "*-*.dist-info", SearchOption.TopDirectoryOnly) - .Select(Path.GetFileName) - .Where(n => n.StartsWith(moduleName, StringComparison.OrdinalIgnoreCase)) // Module name can be capitalized differently. - .ToArray(); + var versionFolder = installationFolder; + while (!string.IsNullOrEmpty(versionFolder)) { + // If module is in site-packages and is versioned, then unique id = name + version + interpreter version. + // Example: 'requests' and 'requests-2.21.0.dist-info'. + // TODO: for egg (https://github.com/microsoft/python-language-server/issues/196), consider *.egg-info + var folders = fs.GetFileSystemEntries(versionFolder, "*-*.dist-info", SearchOption.TopDirectoryOnly) + .Select(Path.GetFileName) + .Where(n => n.StartsWith(moduleRootName, StringComparison.OrdinalIgnoreCase)) // Module name can be capitalized differently. + .ToArray(); - if (folders.Length == 1) { - var fileName = Path.GetFileNameWithoutExtension(folders[0]); - var dash = fileName.IndexOf('-'); - return $"{fileName.Substring(0, dash)}({fileName.Substring(dash + 1)})"; + if (folders.Length == 1) { + var fileName = Path.GetFileNameWithoutExtension(folders[0]); + var dash = fileName.IndexOf('-'); + return $"{moduleName}({fileName.Substring(dash + 1)})"; + } + // Move up if nothing is found. + versionFolder = Path.GetDirectoryName(versionFolder); } } + var config = interpreter.Configuration; if (moduleType == ModuleType.Builtins || moduleType == ModuleType.CompiledBuiltin || - string.IsNullOrEmpty(filePath) || fs.IsPathUnderRoot(standardLibraryPath, filePath)) { + string.IsNullOrEmpty(filePath) || modulePathType == PythonLibraryPathType.StdLib) { // If module is a standard library, unique id is its name + interpreter version. return $"{moduleName}({config.Version.Major}.{config.Version.Minor})"; } @@ -72,17 +79,22 @@ public static string GetUniqieId(string moduleName, string filePath, ModuleType private static string HashModuleContent(string moduleFolder, IFileSystem fs) { // Hash file sizes - using (var sha256 = SHA256.Create()) { - var total = fs - .GetFileSystemEntries(moduleFolder, "*.*", SearchOption.AllDirectories) - .Where(fs.FileExists) - .Select(fs.FileSize) - .Aggregate((hash, e) => unchecked(hash * 31 ^ e.GetHashCode())); + var total = fs + .GetFileSystemEntries(moduleFolder, "*.*", SearchOption.AllDirectories) + .Where(fs.FileExists) + .Select(fs.FileSize) + .Aggregate((hash, e) => unchecked(hash * 31 ^ e.GetHashCode())); + + return ((uint)total).ToString(); + } - return Convert - .ToBase64String(sha256.ComputeHash(BitConverter.GetBytes(total))) - .Replace('/', '_').Replace('+', '-'); + private static PythonLibraryPathType GetModulePathType(string modulePath, IEnumerable libraryPaths, IFileSystem fs) { + if (string.IsNullOrEmpty(modulePath)) { + return PythonLibraryPathType.Unspecified; } + return libraryPaths + .OrderByDescending(p => p.Path.Length) + .FirstOrDefault(p => fs.IsPathUnderRoot(p.Path, modulePath))?.Type ?? PythonLibraryPathType.Unspecified; } } } diff --git a/src/Caching/Impl/QualifiedNameParts.cs b/src/Caching/Impl/QualifiedNameParts.cs new file mode 100644 index 000000000..3bbb431bb --- /dev/null +++ b/src/Caching/Impl/QualifiedNameParts.cs @@ -0,0 +1,36 @@ +// Copyright(c) Microsoft Corporation +// All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the License); you may not use +// this file except in compliance with the License. You may obtain a copy of the +// License at http://www.apache.org/licenses/LICENSE-2.0 +// +// THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS +// OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY +// IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +// MERCHANTABILITY OR NON-INFRINGEMENT. +// +// See the Apache Version 2.0 License for specific language governing +// permissions and limitations under the License. + +using System.Collections.Generic; + +namespace Microsoft.Python.Analysis.Caching { + public enum ObjectType { + Type, + Instance, + Module, + VariableModule, + BuiltinModule, + NamedTuple + } + + internal struct QualifiedNameParts { + /// Object type. + public ObjectType ObjectType; + /// Module name. + public string ModuleName; + /// Module member names such as 'A', 'B', 'C' from module:A.B.C. + public IReadOnlyList MemberNames; + } +} diff --git a/src/Caching/Impl/TypeNames.cs b/src/Caching/Impl/TypeNames.cs index 5408d724f..d60025128 100644 --- a/src/Caching/Impl/TypeNames.cs +++ b/src/Caching/Impl/TypeNames.cs @@ -13,23 +13,38 @@ // See the Apache Version 2.0 License for specific language governing // permissions and limitations under the License. +using System; using System.Collections.Generic; +using System.Linq; using Microsoft.Python.Analysis.Modules; +using Microsoft.Python.Analysis.Specializations.Typing; using Microsoft.Python.Analysis.Types; using Microsoft.Python.Analysis.Values; namespace Microsoft.Python.Analysis.Caching { internal static class TypeNames { - public static string GetQualifiedName(this IMember m) { + /// + /// Constructs persistent member name based on the member and the current module. + /// Persistent name contains complete information for the member restoration code. + /// + public static string GetPersistentQualifiedName(this IMember m) { var t = m.GetPythonType(); if (!t.IsUnknown()) { switch (m) { - case IPythonInstance _: - return $"i:{t.QualifiedName}"; + case IPythonInstance _: // constants and strings map here. + return t is ITypingNamedTupleType nt1 ? $"n:{nt1.QualifiedName}" : $"i:{t.QualifiedName}"; + case IBuiltinsPythonModule b: + return $"b:{b.QualifiedName}"; + case PythonVariableModule vm: + return $"p:{vm.QualifiedName}"; + case IPythonModule mod: + return $"m:{mod.QualifiedName}"; + case ITypingNamedTupleType nt2: + return $"n:{nt2.QualifiedName}"; case IPythonType pt when pt.DeclaringModule.ModuleType == ModuleType.Builtins: - return pt.TypeId == BuiltinTypeId.Ellipsis ? "ellipsis" : pt.Name; + return $"t:{(pt.TypeId == BuiltinTypeId.Ellipsis ? "ellipsis" : pt.QualifiedName)}"; case IPythonType pt: - return pt.QualifiedName; + return $"t:{pt.QualifiedName}"; case null: break; } @@ -42,54 +57,80 @@ public static string GetQualifiedName(this IMember m) { /// qualified name designates instance (prefixed with 'i:'). /// /// Qualified name to split. May include instance prefix. - /// Module name. - /// Module member names such as 'A', 'B', 'C' from module:A.B.C. - /// If true, the qualified name describes instance of a type. - public static bool DeconstructQualifiedName(string qualifiedName, out string moduleName, out IReadOnlyList memberNames, out bool isInstance) { - moduleName = null; - memberNames = null; - isInstance = false; - + /// Qualified name parts. + public static bool DeconstructQualifiedName(string qualifiedName, out QualifiedNameParts parts) { + parts = new QualifiedNameParts(); if (string.IsNullOrEmpty(qualifiedName)) { return false; } - isInstance = qualifiedName.StartsWith("i:"); - qualifiedName = isInstance ? qualifiedName.Substring(2) : qualifiedName; + GetObjectTypeFromPrefix(qualifiedName, ref parts, out var prefixOffset); + GetModuleNameAndMembers(qualifiedName, ref parts, prefixOffset); - if (qualifiedName == "..." || qualifiedName == "ellipsis") { - moduleName = @"builtins"; - memberNames = new[] { "ellipsis" }; - return true; + return !string.IsNullOrEmpty(parts.ModuleName); + } + + private static void GetObjectTypeFromPrefix(string qualifiedName, ref QualifiedNameParts parts, out int prefixOffset) { + prefixOffset = 2; + if (qualifiedName.StartsWith("i:")) { + parts.ObjectType = ObjectType.Instance; + } else if (qualifiedName.StartsWith("m:")) { + parts.ObjectType = ObjectType.Module; + } else if (qualifiedName.StartsWith("p:")) { + parts.ObjectType = ObjectType.VariableModule; + } else if (qualifiedName.StartsWith("b:")) { + parts.ObjectType = ObjectType.BuiltinModule; + } else if (qualifiedName.StartsWith("t:")) { + parts.ObjectType = ObjectType.Type; + } else if (qualifiedName.StartsWith("n:")) { + parts.ObjectType = ObjectType.NamedTuple; + } else { + // Unprefixed name is typically an argument to another type like Union[int, typing:Any] + parts.ObjectType = ObjectType.Type; + prefixOffset = 0; } + } - var moduleSeparatorIndex = qualifiedName.IndexOf(':'); + private static void GetModuleNameAndMembers(string qualifiedName, ref QualifiedNameParts parts, int prefixOffset) { + // Strip the prefix, turning i:module:A.B.C into module:A.B.C + var typeName = qualifiedName.Substring(prefixOffset); + + var moduleSeparatorIndex = typeName.IndexOf(':'); if (moduleSeparatorIndex < 0) { - moduleName = @"builtins"; - memberNames = new[] { qualifiedName }; - return true; + switch (parts.ObjectType) { + case ObjectType.Type: + case ObjectType.Instance: + // No module name means built-in type like 'int' or 'i:str'. + parts.ModuleName = @"builtins"; + parts.MemberNames = typeName == "..." ? new[] { "ellipsis" } : typeName.Split('.').ToArray(); + break; + default: + parts.ModuleName = typeName; + parts.MemberNames = Array.Empty(); + break; + } + return; } - - moduleName = qualifiedName.Substring(0, moduleSeparatorIndex); - // First chunk is qualified module name except dots in braces. - // Builtin types don't have module prefix. - memberNames = GetParts(qualifiedName.Substring(moduleSeparatorIndex+1)); - return !string.IsNullOrEmpty(moduleName); + + // Extract module name and member names, of any. + parts.ModuleName = typeName.Substring(0, moduleSeparatorIndex); + var memberNamesOffset = parts.ModuleName.Length + 1; + parts.MemberNames = GetTypeNames(typeName.Substring(memberNamesOffset), '.'); } - private static IReadOnlyList GetParts(string qualifiedTypeName) { + public static IReadOnlyList GetTypeNames(string qualifiedTypeName, char separator) { var parts = new List(); for (var i = 0; i < qualifiedTypeName.Length; i++) { - var part = GetSubPart(qualifiedTypeName, ref i); + var part = GetTypeName(qualifiedTypeName, ref i, separator); if (string.IsNullOrEmpty(part)) { break; } - parts.Add(part); + parts.Add(part.Trim()); } return parts; } - private static string GetSubPart(string s, ref int i) { + public static string GetTypeName(string s, ref int i, char separator) { var braceCounter = new Stack(); var start = i; for (; i < s.Length; i++) { @@ -106,12 +147,12 @@ private static string GetSubPart(string s, ref int i) { } } - if (braceCounter.Count == 0 && ch == '.') { + if (braceCounter.Count == 0 && ch == separator) { break; } } - return s.Substring(start, i - start); + return s.Substring(start, i - start).Trim(); } } } diff --git a/src/Caching/Test/AnalysisCachingTestBase.cs b/src/Caching/Test/AnalysisCachingTestBase.cs index afb91091c..34927e303 100644 --- a/src/Caching/Test/AnalysisCachingTestBase.cs +++ b/src/Caching/Test/AnalysisCachingTestBase.cs @@ -41,6 +41,9 @@ protected string BaselineFilesFolder { } } - protected string GetBaselineFileName(string testName) => Path.ChangeExtension(Path.Combine(BaselineFilesFolder, testName), "json"); + protected string GetBaselineFileName(string testName, string suffix = null) + => Path.ChangeExtension(suffix == null + ? Path.Combine(BaselineFilesFolder, testName) + : Path.Combine(BaselineFilesFolder, testName + suffix), "json"); } } diff --git a/src/Caching/Test/ClassesTests.cs b/src/Caching/Test/ClassesTests.cs index f0b06de74..adaa23093 100644 --- a/src/Caching/Test/ClassesTests.cs +++ b/src/Caching/Test/ClassesTests.cs @@ -15,6 +15,7 @@ using System.Threading.Tasks; using Microsoft.Python.Analysis.Caching.Models; +using Microsoft.Python.Analysis.Caching.Tests.FluentAssertions; using Microsoft.VisualStudio.TestTools.UnitTesting; using TestUtilities; diff --git a/src/Caching/Test/CoreTests.cs b/src/Caching/Test/CoreTests.cs index 38bb3b3c0..c5cd6ea1e 100644 --- a/src/Caching/Test/CoreTests.cs +++ b/src/Caching/Test/CoreTests.cs @@ -16,6 +16,8 @@ using System.Threading.Tasks; using FluentAssertions; using Microsoft.Python.Analysis.Caching.Models; +using Microsoft.Python.Analysis.Tests.FluentAssertions; +using Microsoft.Python.Parsing.Tests; using Microsoft.VisualStudio.TestTools.UnitTesting; using TestUtilities; @@ -32,6 +34,7 @@ public void TestInitialize() public void Cleanup() => TestEnvironmentImpl.TestCleanup(); private string BaselineFileName => GetBaselineFileName(TestContext.TestName); + private string GetBaselineFileNameWithSuffix(string suffix) => GetBaselineFileName(TestContext.TestName, suffix); [TestMethod, Priority(0)] public async Task SmokeTest() { @@ -61,27 +64,51 @@ def func(): Baseline.CompareToFile(BaselineFileName, json); } - [DataTestMethod, Priority(0)] - [DataRow("", null, null, false)] - [DataRow("str", "builtins", "str", false)] - [DataRow("i:str", "builtins", "str", true)] - [DataRow("i:...", "builtins", "ellipsis", true)] - [DataRow("ellipsis", "builtins", "ellipsis", false)] - [DataRow("i:builtins:str", "builtins", "str", true)] - [DataRow("i:mod:x", "mod", "x", true)] - [DataRow("typing:Union[str, tuple]", "typing", "Union[str, tuple]", false)] - [DataRow("typing:Union[typing:Any, mod:y]", "typing", "Union[typing:Any, mod:y]", false)] - [DataRow("typing:Union[typing:Union[str, int], mod:y]", "typing", "Union[typing:Union[str, int], mod:y]", false)] - public void QualifiedNames(string qualifiedName, string moduleName, string typeName, bool isInstance) { - TypeNames.DeconstructQualifiedName(qualifiedName, out var actualModuleName, out var actualMemberNames, out var actualIsInstance); - actualModuleName.Should().Be(moduleName); - if (string.IsNullOrEmpty(qualifiedName)) { - actualMemberNames.Should().BeNull(); - } else { - actualMemberNames[0].Should().Be(typeName); + [DataRow("t:str", "builtins", "str", ObjectType.Type)] + [DataRow("i:str", "builtins", "str", ObjectType.Instance)] + [DataRow("i:...", "builtins", "ellipsis", ObjectType.Instance)] + [DataRow("t:ellipsis", "builtins", "ellipsis", ObjectType.Type)] + [DataRow("i:builtins:str", "builtins", "str", ObjectType.Instance)] + [DataRow("i:mod:x", "mod", "x", ObjectType.Instance)] + [DataRow("t:typing:Union[str, tuple]", "typing", "Union[str, tuple]", ObjectType.Type)] + [DataRow("t:typing:Union[typing:Any, mod:y]", "typing", "Union[typing:Any, mod:y]", ObjectType.Type)] + [DataRow("t:typing:Union[typing:Union[str, int], mod:y]", "typing", "Union[typing:Union[str, int], mod:y]", ObjectType.Type)] + [DataRow("m:typing", "typing", "", ObjectType.Module)] + [DataRow("p:A", "A", "", ObjectType.VariableModule)] + public void QualifiedNames(string qualifiedName, string moduleName, string typeName, ObjectType objectType) { + TypeNames.DeconstructQualifiedName(qualifiedName, out var parts); + parts.ModuleName.Should().Be(moduleName); + switch (objectType) { + case ObjectType.Instance: + case ObjectType.Type: + parts.MemberNames[0].Should().Be(typeName); + break; + default: + parts.MemberNames.Should().BeEmpty(); + break; } - actualIsInstance.Should().Be(isInstance); + parts.ObjectType.Should().Be(objectType); + } + + [DataTestMethod, Priority(0)] + [DataRow(true)] + [DataRow(false)] + public async Task VersionHandling(bool is3x) { + const string code = @" +if sys.version_info >= (3, 0): + def func(a, b, c): ... +else: + def func(a): ... +"; + var analysis = await GetAnalysisAsync(code, is3x ? PythonVersions.LatestAvailable3X : PythonVersions.LatestAvailable2X); + analysis.Should().HaveFunction("func") + .Which.Should().HaveSingleOverload() + .Which.Should().HaveParameters(is3x ? new[] { "a", "b", "c" } : new[] { "a" }); + + var model = ModuleModel.FromAnalysis(analysis, Services); + var json = ToJson(model); + Baseline.CompareToFile(GetBaselineFileNameWithSuffix(is3x ? "3" : "2"), json); } } } diff --git a/src/Caching/Test/Files/Builtins.json b/src/Caching/Test/Files/Builtins.json deleted file mode 100644 index 8a5415c33..000000000 --- a/src/Caching/Test/Files/Builtins.json +++ /dev/null @@ -1,59942 +0,0 @@ -{ - "UniqueId": "builtins(3.7)", - "Documentation": "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices.", - "Functions": [ - { - "Documentation": "", - "Overloads": [ - { - "Parameters": [], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24816593, - "Name": "type", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "__build_class__(func, name, *bases, metaclass=None, **kwds) -> class\n\nInternal helper function used by the class statement.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "func", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "bases", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "metaclass", - "Type": null, - "DefaultValue": null, - "Kind": 3 - }, - { - "Name": "kwds", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 186877360, - "Name": "__build_class__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "__import__(name, globals=None, locals=None, fromlist=(), level=0) -> module\n\nImport a module. Because this function is meant for use by the Python\ninterpreter and not for general use, it is better to use\nimportlib.import_module() to programmatically import a module.\n\nThe globals argument is only used to determine the context;\nthey are not modified. The locals argument is unused. The fromlist\nshould be a list of names to emulate ``from name import ...'', or an\nempty list to emulate ``import name''.\nWhen importing a module from a package, note that __import__('A.B', ...)\nreturns package A when fromlist is empty, but its submodule B when\nfromlist is not empty. The level argument is used to determine whether to\nperform absolute or relative imports: 0 is absolute, while a positive number\nis the number of parent directories to search relative to the current module.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "globals", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "locals", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "fromlist", - "Type": "tuple", - "DefaultValue": "i:tuple", - "Kind": 0 - }, - { - "Name": "level", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -200972932, - "Name": "__import__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the absolute value of the argument.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "x", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 781563, - "Name": "abs", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return True if bool(x) is True for all values x in the iterable.\n\nIf the iterable is empty, return True.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "iterable", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 781866, - "Name": "all", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return True if bool(x) is True for any x in the iterable.\n\nIf the iterable is empty, return False.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "iterable", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 781941, - "Name": "any", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return an ASCII-only representation of an object.\n\nAs repr(), return a string containing a printable representation of an\nobject, but escape the non-ASCII characters in the string returned by\nrepr() using \\\\x, \\\\u or \\\\U escapes. This generates a string similar\nto that returned by repr() in Python 2.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "obj", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 751576474, - "Name": "ascii", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the binary representation of an integer.\n\n >>> bin(2796202)\n '0b1010101010101010101010'", - "Overloads": [ - { - "Parameters": [ - { - "Name": "number", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 782736, - "Name": "bin", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "breakpoint(*args, **kws)\n\nCall sys.breakpointhook(*args, **kws). sys.breakpointhook() must accept\nwhatever arguments are passed.\n\nBy default, this drops you into the pdb debugger.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kws", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1356147896, - "Name": "breakpoint", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return whether the object is callable (i.e., some kind of function).\n\nNote that classes are callable, as are instances of classes with a\n__call__() method.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "obj", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1205971407, - "Name": "callable", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "i", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 783670, - "Name": "chr", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Compile source into a code object that can be executed by exec() or eval().\n\nThe source code may represent a Python module, statement or expression.\nThe filename will be used for run-time error messages.\nThe mode must be 'exec' to compile a module, 'single' to compile a\nsingle (interactive) statement, or 'eval' to compile an expression.\nThe flags argument, if present, controls which future statements influence\nthe compilation of the code.\nThe dont_inherit argument, if true, stops the compilation inheriting\nthe effects of any future statements in effect in the code calling\ncompile; if absent or false these statements do influence the compilation,\nin addition to any features explicitly specified.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "source", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "filename", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "mode", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "flags", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "dont_inherit", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "optimize", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1914543556, - "Name": "compile", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "interactive prompt objects for printing the license text, a list of\n contributors and the copyright notice.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1298046352, - "Name": "copyright", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "interactive prompt objects for printing the license text, a list of\n contributors and the copyright notice.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1836401501, - "Name": "credits", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Deletes the named attribute from the given object.\n\ndelattr(x, 'y') is equivalent to ``del x.y''", - "Overloads": [ - { - "Parameters": [ - { - "Name": "obj", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1314690939, - "Name": "delattr", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "dir([object]) -> list of strings\n\nIf called without an argument, return the names in the current scope.\nElse, return an alphabetized list of names comprising (some of) the attributes\nof the given object, and of attributes reachable from it.\nIf the object supplies a method named __dir__, it will be used; otherwise\nthe default dir() logic is used and returns:\n for a module object: the module's attributes.\n for a class object: its attributes, and recursively the attributes\n of its bases.\n for any other object: its attributes, its class's attributes, and\n recursively the attributes of its class's base classes.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "object", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:list" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 784662, - "Name": "dir", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the tuple (x//y, x%y). Invariant: div*y + mod == x.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "x", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "y", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1901256616, - "Name": "divmod", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Evaluate the given source in the context of globals and locals.\n\nThe source may be a string representing a Python expression\nor a code object as returned by compile().\nThe globals must be a dictionary and locals can be any mapping,\ndefaulting to the current globals and locals.\nIf only globals is given, locals defaults to it.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "source", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "globals", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "locals", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "object" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24366387, - "Name": "eval", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Execute the given source in the context of globals and locals.\n\nThe source may be a string representing one or more Python statements\nor a code object as returned by compile().\nThe globals must be a dictionary and locals can be any mapping,\ndefaulting to the current globals and locals.\nIf only globals is given, locals defaults to it.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "source", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "globals", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "locals", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24368424, - "Name": "exec", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "code", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24368565, - "Name": "exit", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return value.__format__(format_spec)\n\nformat_spec defaults to the empty string.\nSee the Format Specification Mini-Language section of help('FORMATTING') for\ndetails.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "format_spec", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1963936462, - "Name": "format", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "getattr(object, name[, default]) -> value\n\nGet a named attribute from an object; getattr(x, 'y') is equivalent to x.y.\nWhen a default argument is given, it is returned when the attribute doesn't\nexist; without it, an exception is raised in that case.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "object", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "default", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1355208272, - "Name": "getattr", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the dictionary containing the current scope's global variables.\n\nNOTE: Updates to this dictionary *will* affect name lookups in the current\nglobal scope and vice-versa.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": "i:dict" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1551006009, - "Name": "globals", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return whether the object has an attribute with the given name.\n\nThis is done by calling getattr(obj, name) and catching AttributeError.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "obj", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 2127271828, - "Name": "hasattr", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the hash value for the given object.\n\nTwo objects that compare equal must also have the same hash value, but the\nreverse is not necessarily true.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "obj", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24436133, - "Name": "hash", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Define the builtin 'help'.\n\n This is a wrapper around pydoc.help that provides a helpful message\n when 'help' is typed at the Python interactive prompt.\n\n Calling help() at the Python prompt starts an interactive help session.\n Calling help(thing) prints help for the python object 'thing'.\n ", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwds", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24439768, - "Name": "help", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the hexadecimal representation of an integer.\n\n >>> hex(12648430)\n '0xc0ffee'", - "Overloads": [ - { - "Parameters": [ - { - "Name": "number", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 788388, - "Name": "hex", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the identity of an object.\n\nThis is guaranteed to be unique among simultaneously existing objects.\n(CPython uses the object's memory address.)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "obj", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 25458, - "Name": "id", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Read a string from standard input. The trailing newline is stripped.\n\nThe prompt string, if given, is printed to standard output without a\ntrailing newline before reading input.\n\nIf the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.\nOn *nix systems, readline is used if available.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "prompt", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 758828563, - "Name": "input", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return whether an object is an instance of a class or of a subclass thereof.\n\nA tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to\ncheck against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)\nor ...`` etc.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "obj", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "class_or_tuple", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1317005078, - "Name": "isinstance", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return whether 'cls' is a derived from another class or is the same class.\n\nA tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to\ncheck against. This is equivalent to ``issubclass(x, A) or issubclass(x, B)\nor ...`` etc.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "class_or_tuple", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1314249287, - "Name": "issubclass", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "iter(iterable) -> iterator\niter(callable, sentinel) -> iterator\n\nGet an iterator from an object. In the first form, the argument must\nsupply its own iterator, or be a sequence.\nIn the second form, the callable is called until it returns the sentinel.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "callable", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sentinel", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24483759, - "Name": "iter", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the number of items in a container.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "obj", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 792222, - "Name": "len", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "interactive prompt objects for printing the license text, a list of\n contributors and the copyright notice.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1596689482, - "Name": "license", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a dictionary containing the current scope's local variables.\n\nNOTE: Whether or not updates to this dictionary will affect name lookups in\nthe local scope and vice-versa is *implementation dependent* and not\ncovered by any backwards compatibility guarantees.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": "i:dict" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 2135253311, - "Name": "locals", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "max(iterable, *[, default=obj, key=func]) -> value\nmax(arg1, arg2, *args, *[, key=func]) -> value\n\nWith a single iterable argument, return its biggest item. The\ndefault keyword-only argument specifies an object to return if\nthe provided iterable is empty.\nWith two or more arguments, return the largest argument.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "iterable", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "default", - "Type": null, - "DefaultValue": null, - "Kind": 3 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 3 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 793069, - "Name": "max", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "min(iterable, *[, default=obj, key=func]) -> value\nmin(arg1, arg2, *args, *[, key=func]) -> value\n\nWith a single iterable argument, return its smallest item. The\ndefault keyword-only argument specifies an object to return if\nthe provided iterable is empty.\nWith two or more arguments, return the smallest argument.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "iterable", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "default", - "Type": null, - "DefaultValue": null, - "Kind": 3 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 3 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 793307, - "Name": "min", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "next(iterator[, default])\n\nReturn the next item from the iterator. If default is given and the iterator\nis exhausted, it is returned instead of raising StopIteration.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "iterator", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "default", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24618890, - "Name": "next", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the octal representation of an integer.\n\n >>> oct(342391)\n '0o1234567'", - "Overloads": [ - { - "Parameters": [ - { - "Name": "number", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 795049, - "Name": "oct", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Open file and return a stream. Raise OSError upon failure.\n\nfile is either a text or byte string giving the name (and the path\nif the file isn't in the current working directory) of the file to\nbe opened or an integer file descriptor of the file to be\nwrapped. (If a file descriptor is given, it is closed when the\nreturned I/O object is closed, unless closefd is set to False.)\n\nmode is an optional string that specifies the mode in which the file\nis opened. It defaults to 'r' which means open for reading in text\nmode. Other common values are 'w' for writing (truncating the file if\nit already exists), 'x' for creating and writing to a new file, and\n'a' for appending (which on some Unix systems, means that all writes\nappend to the end of the file regardless of the current seek position).\nIn text mode, if encoding is not specified the encoding used is platform\ndependent: locale.getpreferredencoding(False) is called to get the\ncurrent locale encoding. (For reading and writing raw bytes use binary\nmode and leave encoding unspecified.) The available modes are:\n\n========= ===============================================================\nCharacter Meaning\n--------- ---------------------------------------------------------------\n'r' open for reading (default)\n'w' open for writing, truncating the file first\n'x' create a new file and open it for writing\n'a' open for writing, appending to the end of the file if it exists\n'b' binary mode\n't' text mode (default)\n'+' open a disk file for updating (reading and writing)\n'U' universal newline mode (deprecated)\n========= ===============================================================\n\nThe default mode is 'rt' (open for reading text). For binary random\naccess, the mode 'w+b' opens and truncates the file to 0 bytes, while\n'r+b' opens the file without truncation. The 'x' mode implies 'w' and\nraises an `FileExistsError` if the file already exists.\n\nPython distinguishes between files opened in binary and text modes,\neven when the underlying operating system doesn't. Files opened in\nbinary mode (appending 'b' to the mode argument) return contents as\nbytes objects without any decoding. In text mode (the default, or when\n't' is appended to the mode argument), the contents of the file are\nreturned as strings, the bytes having been first decoded using a\nplatform-dependent encoding or using the specified encoding if given.\n\n'U' mode is deprecated and will raise an exception in future versions\nof Python. It has no effect in Python 3. Use newline to control\nuniversal newlines mode.\n\nbuffering is an optional integer used to set the buffering policy.\nPass 0 to switch buffering off (only allowed in binary mode), 1 to select\nline buffering (only usable in text mode), and an integer > 1 to indicate\nthe size of a fixed-size chunk buffer. When no buffering argument is\ngiven, the default buffering policy works as follows:\n\n* Binary files are buffered in fixed-size chunks; the size of the buffer\n is chosen using a heuristic trying to determine the underlying device's\n \"block size\" and falling back on `io.DEFAULT_BUFFER_SIZE`.\n On many systems, the buffer will typically be 4096 or 8192 bytes long.\n\n* \"Interactive\" text files (files for which isatty() returns True)\n use line buffering. Other text files use the policy described above\n for binary files.\n\nencoding is the name of the encoding used to decode or encode the\nfile. This should only be used in text mode. The default encoding is\nplatform dependent, but any encoding supported by Python can be\npassed. See the codecs module for the list of supported encodings.\n\nerrors is an optional string that specifies how encoding errors are to\nbe handled---this argument should not be used in binary mode. Pass\n'strict' to raise a ValueError exception if there is an encoding error\n(the default of None has the same effect), or pass 'ignore' to ignore\nerrors. (Note that ignoring encoding errors can lead to data loss.)\nSee the documentation for codecs.register or run 'help(codecs.Codec)'\nfor a list of the permitted encoding error strings.\n\nnewline controls how universal newlines works (it only applies to text\nmode). It can be None, '', '\\n', '\\r', and '\\r\\n'. It works as\nfollows:\n\n* On input, if newline is None, universal newlines mode is\n enabled. Lines in the input can end in '\\n', '\\r', or '\\r\\n', and\n these are translated into '\\n' before being returned to the\n caller. If it is '', universal newline mode is enabled, but line\n endings are returned to the caller untranslated. If it has any of\n the other legal values, input lines are only terminated by the given\n string, and the line ending is returned to the caller untranslated.\n\n* On output, if newline is None, any '\\n' characters written are\n translated to the system default line separator, os.linesep. If\n newline is '' or '\\n', no translation takes place. If newline is any\n of the other legal values, any '\\n' characters written are translated\n to the given string.\n\nIf closefd is False, the underlying file descriptor will be kept open\nwhen the file is closed. This does not work when a file name is given\nand must be True in that case.\n\nA custom opener can be used by passing a callable as *opener*. The\nunderlying file descriptor for the file object is then obtained by\ncalling *opener* with (*file*, *flags*). *opener* must return an open\nfile descriptor (passing os.open as *opener* results in functionality\nsimilar to passing None).\n\nopen() returns a file object whose type depends on the mode, and\nthrough which the standard file operations such as reading and writing\nare performed. When open() is used to open a file in a text mode ('w',\n'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open\na file in a binary mode, the returned class varies: in read binary\nmode, it returns a BufferedReader; in write binary and append binary\nmodes, it returns a BufferedWriter, and in read/write mode, it returns\na BufferedRandom.\n\nIt is also possible to use a string or bytearray as a file for both\nreading and writing. For strings StringIO can be used like a file\nopened in a text mode, and for bytes a BytesIO can be used like a file\nopened in a binary mode.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "file", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "mode", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "buffering", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "encoding", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "errors", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "newline", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "closefd", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "opener", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24658657, - "Name": "open", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the Unicode code point for a one-character string.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "c", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 795498, - "Name": "ord", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Equivalent to x**y (with two arguments) or x**y % z (with three arguments)\n\nSome types, such as ints, are able to use a more efficient algorithm when\ninvoked using the three argument form.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "x", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "y", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "z", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 796385, - "Name": "pow", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n\nPrints the values to a stream, or to sys.stdout by default.\nOptional keyword arguments:\nfile: a file-like object (stream); defaults to the current sys.stdout.\nsep: string inserted between values, default a space.\nend: string appended after the last value, default a newline.\nflush: whether to forcibly flush the stream.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 765405430, - "Name": "print", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "code", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24723174, - "Name": "quit", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "Overloads": [ - { - "Parameters": [], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 766750598, - "Name": "range", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the canonical string representation of the object.\n\nFor many object types, including most builtins, eval(repr(obj)) == obj.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "obj", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24737804, - "Name": "repr", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Round a number to a given precision in decimal digits.\n\nThe return value is an integer if ndigits is omitted or None. Otherwise\nthe return value has the same type as the number. ndigits may be negative.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "number", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "ndigits", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 767174615, - "Name": "round", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Sets the named attribute on the given object to the specified value.\n\nsetattr(x, 'y', v) is equivalent to ``x.y = v''", - "Overloads": [ - { - "Parameters": [ - { - "Name": "obj", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -879649444, - "Name": "setattr", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a new list containing all items from the iterable in ascending order.\n\nA custom key function can be supplied to customize the sort order, and the\nreverse flag can be set to request the result in descending order.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "iterable", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:list" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1958845036, - "Name": "sorted", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the sum of a 'start' value (default: 0) plus an iterable of numbers\n\nWhen the iterable is empty, return the start value.\nThis function is intended specifically for use with numeric values and may\nreject non-numeric types.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "iterable", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 799444, - "Name": "sum", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "vars([object]) -> dictionary\n\nWithout arguments, equivalent to locals().\nWith an argument, equivalent to object.__dict__.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "object", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:dict" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24853187, - "Name": "vars", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "Overloads": [ - { - "Parameters": [], - "ReturnType": "int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 783823, - "Name": "cmp", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Variables": [ - { - "Value": "object", - "Id": 376535734, - "Name": "__Object__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "int", - "Id": -1660953576, - "Name": "__Int__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "bool", - "Id": -149570207, - "Name": "__Bool__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "int", - "Id": 136686707, - "Name": "__Long__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "float", - "Id": -1172856571, - "Name": "__Float__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "complex", - "Id": -1125625831, - "Name": "__Complex__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "tuple", - "Id": -1373807759, - "Name": "__Tuple__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "list", - "Id": 131307029, - "Name": "__List__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "dict", - "Id": -98202835, - "Name": "__Dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "set", - "Id": -1651986485, - "Name": "__Set__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "frozenset", - "Id": -1845664181, - "Name": "__FrozenSet__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "bytes", - "Id": -50989228, - "Name": "__Bytes__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "bytes_iterator", - "Id": 1196082274, - "Name": "__BytesIterator__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "str", - "Id": -667382010, - "Name": "__Unicode__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "str_iterator", - "Id": 899385876, - "Name": "__UnicodeIterator__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "str", - "Id": -1651541542, - "Name": "__Str__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "str_iterator", - "Id": -1693163288, - "Name": "__StrIterator__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "module", - "Id": -318216541, - "Name": "__Module__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "function", - "Id": -56357041, - "Name": "__Function__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "wrapper_descriptor", - "Id": 2031680028, - "Name": "__BuiltinMethodDescriptor__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "builtin_function_or_method", - "Id": -998173500, - "Name": "__BuiltinFunction__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "generator", - "Id": 1086442300, - "Name": "__Generator__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "property", - "Id": -919605748, - "Name": "__Property__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "classmethod", - "Id": -991650526, - "Name": "__ClassMethod__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "staticmethod", - "Id": 1863225126, - "Name": "__StaticMethod__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "ellipsis", - "Id": 961323528, - "Name": "__Ellipsis__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "tuple_iterator", - "Id": 1754184575, - "Name": "__TupleIterator__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "list_iterator", - "Id": 692195875, - "Name": "__ListIterator__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "dict_keys", - "Id": -414283327, - "Name": "__DictKeys__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "dict_values", - "Id": -623419857, - "Name": "__DictValues__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "dict_items", - "Id": -1322081197, - "Name": "__DictItems__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "set_iterator", - "Id": 1366627801, - "Name": "__SetIterator__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "callable_iterator", - "Id": 1819825725, - "Name": "__CallableIterator__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": null, - "Id": -2048509720, - "Name": "__builtin_module_names__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:ellipsis", - "Id": 1631567368, - "Name": "Ellipsis", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:OSError", - "Id": 763574764, - "Name": "EnvironmentError", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:OSError", - "Id": -172840821, - "Name": "IOError", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:NotImplementedType", - "Id": -1818427354, - "Name": "NotImplemented", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:OSError", - "Id": 1763918588, - "Name": "WindowsError", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": null, - "Id": -1636005055, - "Name": "__doc__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": null, - "Id": 1097116834, - "Name": "__name__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": null, - "Id": 75395663, - "Name": "__package__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "bool", - "Id": 23856709, - "Name": "True", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "bool", - "Id": 726114124, - "Name": "False", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "__NoneType__", - "Id": 23674863, - "Name": "None", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Classes": [ - { - "Documentation": null, - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "NotImplementedType", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "NotImplementedType", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "NotImplementedType", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -544113923, - "Name": "__reduce__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return repr(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "NotImplementedType", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1215429388, - "Name": "__repr__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "NotImplementedType", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 2136768640, - "Name": "NotImplementedType", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "Bases": [], - "Methods": [], - "Properties": [], - "Fields": [ - { - "Value": null, - "Id": 1097116834, - "Name": "__name__", - "IndexSpan": null - }, - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 1423120691, - "Name": "__Unknown__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "the type of the None object", - "Bases": [], - "Methods": [], - "Properties": [], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 1499999113, - "Name": "__NoneType__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "The most base type", - "Bases": [], - "Methods": [ - { - "Documentation": "Implement delattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "object", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 2095540485, - "Name": "__delattr__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Default dir() implementation.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "object", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:list" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1636169386, - "Name": "__dir__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self==value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "object", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748372547, - "Name": "__eq__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Default object formatter.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "object", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "format_spec", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 695475534, - "Name": "__format__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "object", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "object", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "object", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return hash(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "object", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "The most base type", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "object", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "object", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "object", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self integer\nint(x, base=10) -> integer\n\nConvert a number or string to an integer, or return 0 if no arguments\nare given. If x is a number, return x.__int__(). For floating point\nnumbers, this truncates towards zero.\n\nIf x is not a number or if base is given, then x must be a string,\nbytes, or bytearray instance representing an integer literal in the\ngiven base. The literal can be preceded by '+' or '-' and be surrounded\nby whitespace. The base defaults to 10. Valid bases are 0 and 2-36.\nBase 0 means to interpret the base from the string as an integer literal.\n>>> int('0b100', base=0)\n4", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "abs(self)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1639147525, - "Name": "__abs__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self+value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1639102358, - "Name": "__add__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self&value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1638804448, - "Name": "__and__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "self != 0", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 766562625, - "Name": "__bool__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Ceiling of an Integral returns itself.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 785777820, - "Name": "__ceil__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return divmod(self, value).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 589685672, - "Name": "__divmod__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self==value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748372547, - "Name": "__eq__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "float(self)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1457457445, - "Name": "__float__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Flooring an Integral returns itself.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1457872597, - "Name": "__floor__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self//value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 778272028, - "Name": "__floordiv__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "format_spec", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 695475534, - "Name": "__format__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -488627138, - "Name": "__getnewargs__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return hash(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self converted to an integer, if self is suitable for use as an index into a list.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -127776229, - "Name": "__index__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "int([x]) -> integer\nint(x, base=10) -> integer\n\nConvert a number or string to an integer, or return 0 if no arguments\nare given. If x is a number, return x.__int__(). For floating point\nnumbers, this truncates towards zero.\n\nIf x is not a number or if base is given, then x must be a string,\nbytes, or bytearray instance representing an integer literal in the\ngiven base. The literal can be preceded by '+' or '-' and be surrounded\nby whitespace. The base defaults to 10. Valid bases are 0 and 2-36.\nBase 0 means to interpret the base from the string as an integer literal.\n>>> int('0b100', base=0)\n4", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "x", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "base", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "int(self)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1631400904, - "Name": "__int__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "~self", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 849070445, - "Name": "__invert__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<>self.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1555101003, - "Name": "__rrshift__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -900426137, - "Name": "__rshift__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return value-self.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1228492261, - "Name": "__rsub__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return value/self.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1563284312, - "Name": "__rtruediv__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return value^self.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1232946496, - "Name": "__rxor__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Returns size in memory, in bytes.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1069167279, - "Name": "__sizeof__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return str(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1621988870, - "Name": "__str__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self-value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1621974455, - "Name": "__sub__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self/value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:float" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -375214324, - "Name": "__truediv__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Truncating an Integral returns itself.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1175294069, - "Name": "__trunc__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self^value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1617520220, - "Name": "__xor__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Number of bits necessary to represent self in binary.\n\n>>> bin(37)\n'0b100101'\n>>> (37).bit_length()\n6", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 641823151, - "Name": "bit_length", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Returns self, the complex conjugate of any int.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:complex" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -903692703, - "Name": "conjugate", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the integer represented by the given array of bytes.\n\n bytes\n Holds the array of bytes to convert. The argument must either\n support the buffer protocol or be an iterable object producing bytes.\n Bytes and bytearray are examples of built-in objects that support the\n buffer protocol.\n byteorder\n The byte order used to represent the integer. If byteorder is 'big',\n the most significant byte is at the beginning of the byte array. If\n byteorder is 'little', the most significant byte is at the end of the\n byte array. To request the native byte order of the host system, use\n `sys.byteorder' as the byte order value.\n signed\n Indicates whether two's complement is used to represent the integer.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "type", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "bytes", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "byteorder", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -190029075, - "Name": "from_bytes", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return an array of bytes representing an integer.\n\n length\n Length of bytes object to use. An OverflowError is raised if the\n integer is not representable with the given number of bytes.\n byteorder\n The byte order used to represent the integer. If byteorder is 'big',\n the most significant byte is at the beginning of the byte array. If\n byteorder is 'little', the most significant byte is at the end of the\n byte array. To request the native byte order of the host system, use\n `sys.byteorder' as the byte order value.\n signed\n Determines whether two's complement is used to represent the integer.\n If signed is False and a negative integer is given, an OverflowError\n is raised.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "length", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "byteorder", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -71556418, - "Name": "to_bytes", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [ - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 985628143, - "Name": "denominator", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 24476897, - "Name": "imag", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 1522491474, - "Name": "numerator", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 24737333, - "Name": "real", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 789624, - "Name": "int", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "bool(x) -> bool\n\nReturns True when the argument x is true, False otherwise.\nThe builtins True and False are the only two instances of the class bool.\nThe class bool is a subclass of the class int, and cannot be subclassed.", - "Bases": [ - "int" - ], - "Methods": [ - { - "Documentation": "Return self&value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bool", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1638804448, - "Name": "__and__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "bool(x) -> bool\n\nReturns True when the argument x is true, False otherwise.\nThe builtins True and False are the only two instances of the class bool.\nThe class bool is a subclass of the class int, and cannot be subclassed.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bool", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "x", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "bool", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self|value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bool", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748671418, - "Name": "__or__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return value&self.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bool", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1211662268, - "Name": "__rand__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return repr(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bool", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1215429388, - "Name": "__repr__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return value|self.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bool", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1623061346, - "Name": "__ror__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return value^self.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bool", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1232946496, - "Name": "__rxor__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return str(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bool", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1621988870, - "Name": "__str__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "bool", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self^value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bool", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1617520220, - "Name": "__xor__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the integer represented by the given array of bytes.\n\n bytes\n Holds the array of bytes to convert. The argument must either\n support the buffer protocol or be an iterable object producing bytes.\n Bytes and bytearray are examples of built-in objects that support the\n buffer protocol.\n byteorder\n The byte order used to represent the integer. If byteorder is 'big',\n the most significant byte is at the beginning of the byte array. If\n byteorder is 'little', the most significant byte is at the end of the\n byte array. To request the native byte order of the host system, use\n `sys.byteorder' as the byte order value.\n signed\n Indicates whether two's complement is used to represent the integer.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "bool", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "type", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "bytes", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "byteorder", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -190029075, - "Name": "from_bytes", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 24270721, - "Name": "bool", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Convert a string or number to a floating point number, if possible.", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "abs(self)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:float" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1639147525, - "Name": "__abs__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self+value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:float" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1639102358, - "Name": "__add__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "self != 0", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 766562625, - "Name": "__bool__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return divmod(self, value).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 589685672, - "Name": "__divmod__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self==value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748372547, - "Name": "__eq__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "float(self)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1457457445, - "Name": "__float__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self//value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 778272028, - "Name": "__floordiv__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Formats the float according to format_spec.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "format_spec", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 695475534, - "Name": "__format__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "You probably don't want to use this function.\n\n typestr\n Must be 'double' or 'float'.\n\nIt exists mainly to be used in Python's test suite.\n\nThis function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,\nlittle-endian' best describes the format of floating point numbers used by the\nC type named by typestr.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "type", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "typestr", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1018863830, - "Name": "__getformat__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -488627138, - "Name": "__getnewargs__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return hash(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Convert a string or number to a floating point number, if possible.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "int(self)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1631400904, - "Name": "__int__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>> (10.0).as_integer_ratio()\n(10, 1)\n>>> (0.0).as_integer_ratio()\n(0, 1)\n>>> (-.25).as_integer_ratio()\n(-1, 4)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1148559724, - "Name": "as_integer_ratio", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self, the complex conjugate of any float.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:complex" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -903692703, - "Name": "conjugate", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Create a floating-point number from a hexadecimal string.\n\n>>> float.fromhex('0x1.ffffp10')\n2047.984375\n>>> float.fromhex('-0x1p-1074')\n-5e-324", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "type", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "string", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 835611450, - "Name": "fromhex", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a hexadecimal representation of a floating-point number.\n\n>>> (-0.1).hex()\n'-0x1.999999999999ap-4'\n>>> 3.14159.hex()\n'0x1.921f9f01b866ep+1'", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 788388, - "Name": "hex", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return True if the float is an integer.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 783186560, - "Name": "is_integer", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [ - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 24476897, - "Name": "imag", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 24737333, - "Name": "real", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 755996837, - "Name": "float", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Create a complex number from a real part and an optional imaginary part.\n\nThis is equivalent to (real + imag*1j) where imag defaults to 0.", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "abs(self)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "complex", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:complex" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1639147525, - "Name": "__abs__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self+value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "complex", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:complex" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1639102358, - "Name": "__add__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "self != 0", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "complex", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 766562625, - "Name": "__bool__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return divmod(self, value).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "complex", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 589685672, - "Name": "__divmod__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self==value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "complex", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748372547, - "Name": "__eq__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "float(self)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "complex", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1457457445, - "Name": "__float__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self//value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "complex", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 778272028, - "Name": "__floordiv__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "complex.__format__() -> str\n\nConvert to a string according to format_spec.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "complex", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "format_spec", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 695475534, - "Name": "__format__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "complex", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "complex", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "complex", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -488627138, - "Name": "__getnewargs__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "complex", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return hash(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "complex", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Create a complex number from a real part and an optional imaginary part.\n\nThis is equivalent to (real + imag*1j) where imag defaults to 0.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "complex", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "complex", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "int(self)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "complex", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1631400904, - "Name": "__int__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "complex", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self complex\n\nReturn the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "complex", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:complex" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -903692703, - "Name": "conjugate", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [ - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 24476897, - "Name": "imag", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 24737333, - "Name": "real", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": -1914540871, - "Name": "complex", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Built-in immutable sequence.\n\nIf no argument is given, the constructor returns an empty tuple.\nIf iterable is specified the tuple is initialized from iterable's items.\n\nIf the argument is a tuple, the return value is the same object.", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return self+value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1639102358, - "Name": "__add__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return key in self.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1841774666, - "Name": "__contains__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self==value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748372547, - "Name": "__eq__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self[key].", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -293179214, - "Name": "__getitem__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -488627138, - "Name": "__getnewargs__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return hash(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Built-in immutable sequence.\n\nIf no argument is given, the constructor returns an empty tuple.\nIf iterable is specified the tuple is initialized from iterable's items.\n\nIf the argument is a tuple, the return value is the same object.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "tuple", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple_iterator" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return len(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1628904226, - "Name": "__len__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "list", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "list", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "x.__getitem__(y) <==> x[y]", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "list", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "index", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -293179214, - "Name": "__getitem__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "list", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement self+=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "list", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 953701999, - "Name": "__iadd__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement self*=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "list", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965298386, - "Name": "__imul__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Built-in mutable sequence.\n\nIf no argument is given, the constructor creates a new empty list.\nThe argument must be an iterable if specified.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "list", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "list", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "list", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:list_iterator" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "list", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return len(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "list", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1628904226, - "Name": "__len__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self new empty dictionary\ndict(mapping) -> new dictionary initialized from a mapping object's\n (key, value) pairs\ndict(iterable) -> new dictionary initialized as if via:\n d = {}\n for k, v in iterable:\n d[k] = v\ndict(**kwargs) -> new dictionary initialized with the name=value pairs\n in the keyword argument list. For example: dict(one=1, two=2)", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "True if the dictionary has the specified key, else False.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1841774666, - "Name": "__contains__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Delete self[key].", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1970845273, - "Name": "__delitem__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self==value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748372547, - "Name": "__eq__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "x.__getitem__(y) <==> x[y]", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -293179214, - "Name": "__getitem__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "dict() -> new empty dictionary\ndict(mapping) -> new dictionary initialized from a mapping object's\n (key, value) pairs\ndict(iterable) -> new dictionary initialized as if via:\n d = {}\n for k, v in iterable:\n d[k] = v\ndict(**kwargs) -> new dictionary initialized with the name=value pairs\n in the keyword argument list. For example: dict(one=1, two=2)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "iterable", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:dict_keys" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return len(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1628904226, - "Name": "__len__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self size of D in memory, in bytes", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1069167279, - "Name": "__sizeof__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "D.clear() -> None. Remove all items from D.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 753216662, - "Name": "clear", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "D.copy() -> a shallow copy of D", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:dict" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24300556, - "Name": "copy", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Create a new dictionary with keys from iterable and values set to value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "type", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "iterable", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:dict" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 134240693, - "Name": "fromkeys", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the value for key if key is in the dictionary, else default.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "default", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:dict" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 787423, - "Name": "get", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "D.items() -> a set-like object providing a view on D's items", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:dict_items" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 758996489, - "Name": "items", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "D.keys() -> a set-like object providing a view on D's keys", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:dict_keys" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24529547, - "Name": "keys", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\nIf key is not found, d is returned if given, otherwise KeyError is raised", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "k", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "d", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:dict_keys" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 796378, - "Name": "pop", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "D.popitem() -> (k, v), remove and return some (key, value) pair as a\n2-tuple; but raise KeyError if D is empty.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "k", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "d", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:dict_items" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1035642093, - "Name": "popitem", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Insert key with a value of default if key is not in the dictionary.\n\nReturn the value for key if key is in the dictionary, else default.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "default", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:dict" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 178640630, - "Name": "setdefault", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "D.update([E, ]**F) -> None. Update D from dict/iterable E and F.\nIf E is present and has a .keys() method, then does: for k in E: D[k] = E[k]\nIf E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v\nIn either case, this is followed by: for k in F: D[k] = F[k]", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "d", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1901098080, - "Name": "update", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "D.values() -> an object providing a view on D's values", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:dict_values" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1886064647, - "Name": "values", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": null - }, - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 24324173, - "Name": "dict", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "set() -> new empty set object\nset(iterable) -> new set object\n\nBuild an unordered collection of unique elements.", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return self&value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:set" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1638804448, - "Name": "__and__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "x.__contains__(y) <==> y in x.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1841774666, - "Name": "__contains__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self==value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748372547, - "Name": "__eq__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self&=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 953999909, - "Name": "__iand__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "set() -> new empty set object\nset(iterable) -> new set object\n\nBuild an unordered collection of unique elements.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "iterable", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self|=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1631373035, - "Name": "__ior__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self-=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 970829902, - "Name": "__isub__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:set_iterator" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self^=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 975284137, - "Name": "__ixor__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return len(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1628904226, - "Name": "__len__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self size of S in memory, in bytes", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1069167279, - "Name": "__sizeof__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self-value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:set" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1621974455, - "Name": "__sub__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self^value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:set" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1617520220, - "Name": "__xor__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Add an element to a set.\n\nThis has no effect if the element is already present.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 781610, - "Name": "add", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Remove all elements from this set.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 753216662, - "Name": "clear", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a shallow copy of a set.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:set" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24300556, - "Name": "copy", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the difference of two or more sets as a new set.\n\n(i.e. all elements that are in this set but not the others.)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "other", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:set" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -946813804, - "Name": "difference", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Remove all elements of another set from this set.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "others", - "Type": null, - "DefaultValue": null, - "Kind": 1 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 2053694164, - "Name": "difference_update", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Remove an element from a set if it is a member.\n\nIf the element is not a member, do nothing.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "elem", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1193668441, - "Name": "discard", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the intersection of two sets as a new set.\n\n(i.e. all elements that are in both sets.)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "other", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:set" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 2011414560, - "Name": "intersection", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Update a set with the intersection of itself and another.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "others", - "Type": null, - "DefaultValue": null, - "Kind": 1 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1074130488, - "Name": "intersection_update", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return True if two sets have a null intersection.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "other", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1041514301, - "Name": "isdisjoint", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Report whether another set contains this set.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "other", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 2076857571, - "Name": "issubset", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Report whether this set contains another set.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "other", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -911398520, - "Name": "issuperset", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Remove and return an arbitrary set element.\nRaises KeyError if the set is empty.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 796378, - "Name": "pop", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Remove an element from a set; it must be a member.\n\nIf the element is not a member, raise a KeyError.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "elem", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1996862629, - "Name": "remove", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the symmetric difference of two sets as a new set.\n\n(i.e. all elements that are in exactly one of the sets.)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "other", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:set" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 796556764, - "Name": "symmetric_difference", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Update a set with the symmetric difference of itself and another.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "others", - "Type": null, - "DefaultValue": null, - "Kind": 1 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -81680244, - "Name": "symmetric_difference_update", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the union of sets as a new set.\n\n(i.e. all elements that are in either set.)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "others", - "Type": null, - "DefaultValue": null, - "Kind": 1 - } - ], - "ReturnType": "i:set" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 769903896, - "Name": "union", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Update a set with the union of itself and others.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "set", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "others", - "Type": null, - "DefaultValue": null, - "Kind": 1 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1901098080, - "Name": "update", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": null - }, - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 798955, - "Name": "set", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "frozenset() -> empty frozenset object\nfrozenset(iterable) -> frozenset object\n\nBuild an immutable unordered collection of unique elements.", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return self&value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:frozenset" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1638804448, - "Name": "__and__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "x.__contains__(y) <==> y in x.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1841774666, - "Name": "__contains__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self==value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748372547, - "Name": "__eq__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return hash(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "frozenset() -> empty frozenset object\nfrozenset(iterable) -> frozenset object\n\nBuild an immutable unordered collection of unique elements.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "iterable", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:set_iterator" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return len(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1628904226, - "Name": "__len__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self size of S in memory, in bytes", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1069167279, - "Name": "__sizeof__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self-value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:frozenset" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1621974455, - "Name": "__sub__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self^value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:frozenset" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1617520220, - "Name": "__xor__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a shallow copy of a set.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:frozenset" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24300556, - "Name": "copy", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the difference of two or more sets as a new set.\n\n(i.e. all elements that are in this set but not the others.)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "other", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:frozenset" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -946813804, - "Name": "difference", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the intersection of two sets as a new set.\n\n(i.e. all elements that are in both sets.)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "other", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:frozenset" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 2011414560, - "Name": "intersection", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return True if two sets have a null intersection.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "other", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1041514301, - "Name": "isdisjoint", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Report whether another set contains this set.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "other", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 2076857571, - "Name": "issubset", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Report whether this set contains another set.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "other", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -911398520, - "Name": "issuperset", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the symmetric difference of two sets as a new set.\n\n(i.e. all elements that are in exactly one of the sets.)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "other", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:frozenset" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 796556764, - "Name": "symmetric_difference", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return the union of sets as a new set.\n\n(i.e. all elements that are in either set.)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "frozenset", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "others", - "Type": null, - "DefaultValue": null, - "Kind": 1 - } - ], - "ReturnType": "i:frozenset" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 769903896, - "Name": "union", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 233394059, - "Name": "frozenset", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "bytes(iterable_of_ints) -> bytes\nbytes(string, encoding[, errors]) -> bytes\nbytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer\nbytes(int) -> bytes object of size given by the parameter initialized with null bytes\nbytes() -> empty bytes object\n\nConstruct an immutable array of bytes from:\n - an iterable yielding integers in range(256)\n - a text string encoded using the specified encoding\n - any object implementing the buffer API.\n - an integer", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return self+value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytes" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1639102358, - "Name": "__add__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return key in self.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1841774666, - "Name": "__contains__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self==value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748372547, - "Name": "__eq__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self[key].", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytes" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -293179214, - "Name": "__getitem__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -488627138, - "Name": "__getnewargs__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return hash(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "bytes(iterable_of_ints) -> bytes\nbytes(string, encoding[, errors]) -> bytes\nbytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer\nbytes(int) -> bytes object of size given by the parameter initialized with null bytes\nbytes() -> empty bytes object\n\nConstruct an immutable array of bytes from:\n - an iterable yielding integers in range(256)\n - a text string encoded using the specified encoding\n - any object implementing the buffer API.\n - an integer", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "string", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "encoding", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "errors", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return len(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1628904226, - "Name": "__len__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self copy of B\n\nReturn a copy of B with only its first character capitalized (ASCII)\nand the rest lower-cased.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytes" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -145846717, - "Name": "capitalize", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.center(width[, fillchar]) -> copy of B\n\nReturn B centered in a string of length width. Padding is\ndone using the specified fill character (default is a space).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "width", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "fillbyte", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytes" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1868701484, - "Name": "center", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.count(sub[, start[, end]]) -> int\n\nReturn the number of non-overlapping occurrences of subsection sub in\nbytes B[start:end]. Optional arguments start and end are interpreted\nas in slice notation.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sub", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 753321816, - "Name": "count", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Decode the bytes using the codec registered for encoding.\n\n encoding\n The encoding with which to decode the bytes.\n errors\n The error handling scheme to use for the handling of decoding errors.\n The default is 'strict' meaning that decoding errors raise a\n UnicodeDecodeError. Other possible values are 'ignore' and 'replace'\n as well as any other name registered with codecs.register_error that\n can handle UnicodeDecodeErrors.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "encoding", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "errors", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1896998085, - "Name": "decode", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.endswith(suffix[, start[, end]]) -> bool\n\nReturn True if B ends with the specified suffix, False otherwise.\nWith optional start, test B beginning at that position.\nWith optional end, stop comparing B at that position.\nsuffix can also be a tuple of bytes to try.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "suffix", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1172635435, - "Name": "endswith", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.expandtabs(tabsize=8) -> copy of B\n\nReturn a copy of B where all tab characters are expanded using spaces.\nIf tabsize is not given, a tab size of 8 characters is assumed.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "tabsize", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytes" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -2134490001, - "Name": "expandtabs", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.find(sub[, start[, end]]) -> int\n\nReturn the lowest index in B where subsection sub is found,\nsuch that sub is contained within B[start,end]. Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sub", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24384080, - "Name": "find", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Create a bytes object from a string of hexadecimal numbers.\n\nSpaces between two numbers are accepted.\nExample: bytes.fromhex('B9 01EF') -> b'\\\\xb9\\\\x01\\\\xef'.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "type", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "string", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 835611450, - "Name": "fromhex", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.hex() -> string\n\nCreate a string of hexadecimal numbers from a bytes object.\nExample: b'\\xb9\\x01\\xef'.hex() -> 'b901ef'.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 788388, - "Name": "hex", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.index(sub[, start[, end]]) -> int\n\nReturn the lowest index in B where subsection sub is found,\nsuch that sub is contained within B[start,end]. Optional\narguments start and end are interpreted as in slice notation.\n\nRaises ValueError when the subsection is not found.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sub", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 758816539, - "Name": "index", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.isalnum() -> bool\n\nReturn True if all characters in B are alphanumeric\nand there is at least one character in B, False otherwise.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -781168486, - "Name": "isalnum", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.isalpha() -> bool\n\nReturn True if all characters in B are alphabetic\nand there is at least one character in B, False otherwise.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -781166979, - "Name": "isalpha", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.isascii() -> bool\n\nReturn True if B is empty or all characters in B are ASCII,\nFalse otherwise.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -780970896, - "Name": "isascii", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.isdigit() -> bool\n\nReturn True if all characters in B are digits\nand there is at least one character in B, False otherwise.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -778494388, - "Name": "isdigit", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.islower() -> bool\n\nReturn True if all cased characters in B are lowercase and there is\nat least one cased character in B, False otherwise.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -770912224, - "Name": "islower", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.isspace() -> bool\n\nReturn True if all characters in B are whitespace\nand there is at least one character in B, False otherwise.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -764439003, - "Name": "isspace", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.istitle() -> bool\n\nReturn True if B is a titlecased string and there is at least one\ncharacter in B, i.e. uppercase characters may only follow uncased\ncharacters and lowercase characters only cased ones. Return False\notherwise.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -763705481, - "Name": "istitle", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.isupper() -> bool\n\nReturn True if all cased characters in B are uppercase and there is\nat least one cased character in B, False otherwise.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -762577471, - "Name": "isupper", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Concatenate any number of bytes objects.\n\nThe bytes whose method is called is inserted in between each pair.\n\nThe result is returned as a new bytes object.\n\nExample: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "iterable_of_bytes", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24508865, - "Name": "join", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.ljust(width[, fillchar]) -> copy of B\n\nReturn B left justified in a string of length width. Padding is\ndone using the specified fill character (default is a space).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "width", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "fillbyte", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytes" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 761484705, - "Name": "ljust", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.lower() -> copy of B\n\nReturn a copy of B with all ASCII characters converted to lowercase.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytes" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 761635146, - "Name": "lower", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Strip leading bytes contained in the argument.\n\nIf the argument is omitted or None, strip leading ASCII whitespace.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "bytes", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 2139470083, - "Name": "lstrip", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a translation table useable for the bytes or bytearray translate method.\n\nThe returned table will be one where each byte in frm is mapped to the byte at\nthe same position in to.\n\nThe bytes objects frm and to must be of the same length.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "frm", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "to", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1060805443, - "Name": "maketrans", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Partition the bytes into three parts using the given separator.\n\nThis will search for the separator sep in the bytes. If the separator is found,\nreturns a 3-tuple containing the part before the separator, the separator\nitself, and the part after it.\n\nIf the separator is not found, returns a 3-tuple containing the original bytes\nobject and two empty bytes objects.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sep", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -2024653645, - "Name": "partition", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a copy with all occurrences of substring old replaced by new.\n\n count\n Maximum number of occurrences to replace.\n -1 (the default value) means replace all occurrences.\n\nIf the optional argument count is given, only the first count occurrences are\nreplaced.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "old", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "new", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "count", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytes" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1770538307, - "Name": "replace", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.rfind(sub[, start[, end]]) -> int\n\nReturn the highest index in B where subsection sub is found,\nsuch that sub is contained within B[start,end]. Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sub", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 766894964, - "Name": "rfind", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.rindex(sub[, start[, end]]) -> int\n\nReturn the highest index in B where subsection sub is found,\nsuch that sub is contained within B[start,end]. Optional\narguments start and end are interpreted as in slice notation.\n\nRaise ValueError when the subsection is not found.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sub", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1993149833, - "Name": "rindex", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.rjust(width[, fillchar]) -> copy of B\n\nReturn B right justified in a string of length width. Padding is\ndone using the specified fill character (default is a space)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "width", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "fillbyte", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytes" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 767025831, - "Name": "rjust", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Partition the bytes into three parts using the given separator.\n\nThis will search for the separator sep in the bytes, starting at the end. If\nthe separator is found, returns a 3-tuple containing the part before the\nseparator, the separator itself, and the part after it.\n\nIf the separator is not found, returns a 3-tuple containing two empty bytes\nobjects and the original bytes object.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sep", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1107721713, - "Name": "rpartition", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a list of the sections in the bytes, using sep as the delimiter.\n\n sep\n The delimiter according which to split the bytes.\n None (the default value) means split on ASCII whitespace characters\n (space, tab, return, newline, formfeed, vertical tab).\n maxsplit\n Maximum number of splits to do.\n -1 (the default value) means no limit.\n\nSplitting is done starting at the end of the bytes and working to the front.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sep", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "maxsplit", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:list" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1983847233, - "Name": "rsplit", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Strip trailing bytes contained in the argument.\n\nIf the argument is omitted or None, strip trailing ASCII whitespace.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "bytes", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1983722307, - "Name": "rstrip", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a list of the sections in the bytes, using sep as the delimiter.\n\n sep\n The delimiter according which to split the bytes.\n None (the default value) means split on ASCII whitespace characters\n (space, tab, return, newline, formfeed, vertical tab).\n maxsplit\n Maximum number of splits to do.\n -1 (the default value) means no limit.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sep", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "maxsplit", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:list" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 768119139, - "Name": "split", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a list of the lines in the bytes, breaking at line boundaries.\n\nLine breaks are not included in the resulting list unless keepends is given and\ntrue.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "keepends", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:list" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1291658108, - "Name": "splitlines", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.startswith(prefix[, start[, end]]) -> bool\n\nReturn True if B starts with the specified prefix, False otherwise.\nWith optional start, test B beginning at that position.\nWith optional end, stop comparing B at that position.\nprefix can also be a tuple of bytes to try.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "prefix", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 65206254, - "Name": "startswith", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Strip leading and trailing bytes contained in the argument.\n\nIf the argument is omitted or None, strip leading and trailing ASCII whitespace.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "bytes", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 768244065, - "Name": "strip", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.swapcase() -> copy of B\n\nReturn a copy of B with uppercase ASCII characters converted\nto lowercase ASCII and vice versa.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytes" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1060209754, - "Name": "swapcase", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.title() -> copy of B\n\nReturn a titlecased version of B, i.e. ASCII words start with uppercase\ncharacters, all remaining cased characters have lowercase.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytes" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 768841889, - "Name": "title", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a copy with each character mapped by the given translation table.\n\n table\n Translation table, which must be a bytes object of length 256.\n\nAll characters occurring in the optional argument delete are removed.\nThe remaining characters are mapped through the given translation table.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "table", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "delete", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytes" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 827988759, - "Name": "translate", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.upper() -> copy of B\n\nReturn a copy of B with all ASCII characters converted to uppercase.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytes" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 769969899, - "Name": "upper", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.zfill(width) -> copy of B\n\nPad a numeric string B with zeros on the left, to fill a field\nof the specified width. B is never truncated.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "width", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytes" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 774283078, - "Name": "zfill", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 752694964, - "Name": "bytes", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes_iterator", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes_iterator", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "bytes_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytes_iterator" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Private method returning an estimate of len(list(it)).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 358836041, - "Name": "__length_hint__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement next(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1101153034, - "Name": "__next__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return state information for pickling.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -544113923, - "Name": "__reduce__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Set state information for unpickling.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytes_iterator", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "state", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1719806726, - "Name": "__setstate__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "bytes_iterator", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": -1994109543, - "Name": "bytes_iterator", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "str(object='') -> str\nstr(bytes_or_buffer[, encoding[, errors]]) -> str\n\nCreate a new string object from the given object. If encoding or\nerrors is specified, then the object must expose a data buffer\nthat will be decoded using the given encoding and error handler.\nOtherwise, returns the result of object.__str__() (if defined)\nor repr(object).\nencoding defaults to sys.getdefaultencoding().\nerrors defaults to 'strict'.", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return self+value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1639102358, - "Name": "__add__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return key in self.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1841774666, - "Name": "__contains__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self==value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748372547, - "Name": "__eq__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a formatted version of the string as described by format_spec.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "format_spec", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 695475534, - "Name": "__format__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self[key].", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -293179214, - "Name": "__getitem__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -488627138, - "Name": "__getnewargs__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return hash(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "str(object='') -> str\nstr(bytes_or_buffer[, encoding[, errors]]) -> str\n\nCreate a new string object from the given object. If encoding or\nerrors is specified, then the object must expose a data buffer\nthat will be decoded using the given encoding and error handler.\nOtherwise, returns the result of object.__str__() (if defined)\nor repr(object).\nencoding defaults to sys.getdefaultencoding().\nerrors defaults to 'strict'.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "bytes_or_buffer", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "encoding", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "errors", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return len(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1628904226, - "Name": "__len__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self int\n\nReturn the number of non-overlapping occurrences of substring sub in\nstring S[start:end]. Optional arguments start and end are\ninterpreted as in slice notation.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sub", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 753321816, - "Name": "count", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Encode the string using the codec registered for encoding.\n\n encoding\n The encoding in which to encode the string.\n errors\n The error handling scheme to use for encoding errors.\n The default is 'strict' meaning that encoding errors raise a\n UnicodeEncodeError. Other possible values are 'ignore', 'replace' and\n 'xmlcharrefreplace' as well as any other name registered with\n codecs.register_error that can handle UnicodeEncodeErrors.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "encoding", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "errors", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1933938925, - "Name": "encode", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "S.endswith(suffix[, start[, end]]) -> bool\n\nReturn True if S ends with the specified suffix, False otherwise.\nWith optional start, test S beginning at that position.\nWith optional end, stop comparing S at that position.\nsuffix can also be a tuple of strings to try.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "suffix", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1172635435, - "Name": "endswith", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a copy where all tab characters are expanded using spaces.\n\nIf tabsize is not given, a tab size of 8 characters is assumed.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "tabsize", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -2134490001, - "Name": "expandtabs", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "S.find(sub[, start[, end]]) -> int\n\nReturn the lowest index in S where substring sub is found,\nsuch that sub is contained within S[start:end]. Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sub", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24384080, - "Name": "find", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "S.format(*args, **kwargs) -> str\n\nReturn a formatted version of S, using substitutions from args and kwargs.\nThe substitutions are identified by braces ('{' and '}').", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1963936462, - "Name": "format", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "S.format_map(mapping) -> str\n\nReturn a formatted version of S, using substitutions from mapping.\nThe substitutions are identified by braces ('{' and '}').", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "mapping", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1943930987, - "Name": "format_map", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "S.index(sub[, start[, end]]) -> int\n\nReturn the lowest index in S where substring sub is found, \nsuch that sub is contained within S[start:end]. Optional\narguments start and end are interpreted as in slice notation.\n\nRaises ValueError when the substring is not found.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sub", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 758816539, - "Name": "index", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return True if the string is an alpha-numeric string, False otherwise.\n\nA string is alpha-numeric if all characters in the string are alpha-numeric and\nthere is at least one character in the string.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -781168486, - "Name": "isalnum", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return True if the string is an alphabetic string, False otherwise.\n\nA string is alphabetic if all characters in the string are alphabetic and there\nis at least one character in the string.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -781166979, - "Name": "isalpha", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return True if all characters in the string are ASCII, False otherwise.\n\nASCII characters have code points in the range U+0000-U+007F.\nEmpty string is ASCII too.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -780970896, - "Name": "isascii", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return True if the string is a decimal string, False otherwise.\n\nA string is a decimal string if all characters in the string are decimal and\nthere is at least one character in the string.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -927011664, - "Name": "isdecimal", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return True if the string is a digit string, False otherwise.\n\nA string is a digit string if all characters in the string are digits and there\nis at least one character in the string.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -778494388, - "Name": "isdigit", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return True if the string is a valid Python identifier, False otherwise.\n\nUse keyword.iskeyword() to test for reserved identifiers such as \"def\" and\n\"class\".", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 401040106, - "Name": "isidentifier", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return True if the string is a lowercase string, False otherwise.\n\nA string is lowercase if all cased characters in the string are lowercase and\nthere is at least one cased character in the string.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -770912224, - "Name": "islower", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return True if the string is a numeric string, False otherwise.\n\nA string is numeric if all characters in the string are numeric and there is at\nleast one character in the string.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -174721940, - "Name": "isnumeric", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return True if the string is printable, False otherwise.\n\nA string is printable if all of its characters are considered printable in\nrepr() or if it is empty.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 346760998, - "Name": "isprintable", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return True if the string is a whitespace string, False otherwise.\n\nA string is whitespace if all characters in the string are whitespace and there\nis at least one character in the string.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -764439003, - "Name": "isspace", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return True if the string is a title-cased string, False otherwise.\n\nIn a title-cased string, upper- and title-case characters may only\nfollow uncased characters and lowercase characters only cased ones.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -763705481, - "Name": "istitle", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return True if the string is an uppercase string, False otherwise.\n\nA string is uppercase if all cased characters in the string are uppercase and\nthere is at least one cased character in the string.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -762577471, - "Name": "isupper", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Concatenate any number of strings.\n\nThe string whose method is called is inserted in between each given string.\nThe result is returned as a new string.\n\nExample: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "iterable", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24508865, - "Name": "join", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a left-justified string of length width.\n\nPadding is done using the specified fill character (default is a space).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "width", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "fillchar", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 761484705, - "Name": "ljust", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a copy of the string converted to lowercase.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 761635146, - "Name": "lower", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a copy of the string with leading whitespace removed.\n\nIf chars is given and not None, remove characters in chars instead.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "chars", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 2139470083, - "Name": "lstrip", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a translation table usable for str.translate().\n\nIf there is only one argument, it must be a dictionary mapping Unicode\nordinals (integers) or characters to Unicode ordinals, strings or None.\nCharacter keys will be then converted to ordinals.\nIf there are two arguments, they must be strings of equal length, and\nin the resulting dictionary, each character in x will be mapped to the\ncharacter at the same position in y. If there is a third argument, it\nmust be a string, whose characters will be mapped to None in the result.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "x", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "y", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "z", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:dict" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1060805443, - "Name": "maketrans", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Partition the string into three parts using the given separator.\n\nThis will search for the separator in the string. If the separator is found,\nreturns a 3-tuple containing the part before the separator, the separator\nitself, and the part after it.\n\nIf the separator is not found, returns a 3-tuple containing the original string\nand two empty strings.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sep", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -2024653645, - "Name": "partition", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a copy with all occurrences of substring old replaced by new.\n\n count\n Maximum number of occurrences to replace.\n -1 (the default value) means replace all occurrences.\n\nIf the optional argument count is given, only the first count occurrences are\nreplaced.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "old", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "new", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "count", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1770538307, - "Name": "replace", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "S.rfind(sub[, start[, end]]) -> int\n\nReturn the highest index in S where substring sub is found,\nsuch that sub is contained within S[start:end]. Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sub", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 766894964, - "Name": "rfind", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "S.rindex(sub[, start[, end]]) -> int\n\nReturn the highest index in S where substring sub is found,\nsuch that sub is contained within S[start:end]. Optional\narguments start and end are interpreted as in slice notation.\n\nRaises ValueError when the substring is not found.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sub", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1993149833, - "Name": "rindex", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a right-justified string of length width.\n\nPadding is done using the specified fill character (default is a space).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "width", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "fillchar", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 767025831, - "Name": "rjust", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Partition the string into three parts using the given separator.\n\nThis will search for the separator in the string, starting at the end. If\nthe separator is found, returns a 3-tuple containing the part before the\nseparator, the separator itself, and the part after it.\n\nIf the separator is not found, returns a 3-tuple containing two empty strings\nand the original string.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sep", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1107721713, - "Name": "rpartition", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a list of the words in the string, using sep as the delimiter string.\n\n sep\n The delimiter according which to split the string.\n None (the default value) means split according to any whitespace,\n and discard empty strings from the result.\n maxsplit\n Maximum number of splits to do.\n -1 (the default value) means no limit.\n\nSplits are done starting at the end of the string and working to the front.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sep", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "maxsplit", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:list" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1983847233, - "Name": "rsplit", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a copy of the string with trailing whitespace removed.\n\nIf chars is given and not None, remove characters in chars instead.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "chars", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1983722307, - "Name": "rstrip", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a list of the words in the string, using sep as the delimiter string.\n\n sep\n The delimiter according which to split the string.\n None (the default value) means split according to any whitespace,\n and discard empty strings from the result.\n maxsplit\n Maximum number of splits to do.\n -1 (the default value) means no limit.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sep", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "maxsplit", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:list" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 768119139, - "Name": "split", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a list of the lines in the string, breaking at line boundaries.\n\nLine breaks are not included in the resulting list unless keepends is given and\ntrue.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "keepends", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:list" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1291658108, - "Name": "splitlines", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "S.startswith(prefix[, start[, end]]) -> bool\n\nReturn True if S starts with the specified prefix, False otherwise.\nWith optional start, test S beginning at that position.\nWith optional end, stop comparing S at that position.\nprefix can also be a tuple of strings to try.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "prefix", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 65206254, - "Name": "startswith", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a copy of the string with leading and trailing whitespace remove.\n\nIf chars is given and not None, remove characters in chars instead.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "chars", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 768244065, - "Name": "strip", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Convert uppercase characters to lowercase and lowercase characters to uppercase.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1060209754, - "Name": "swapcase", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a version of the string where each word is titlecased.\n\nMore specifically, words start with uppercased characters and all remaining\ncased characters have lower case.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 768841889, - "Name": "title", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Replace each character in the string using the given translation table.\n\n table\n Translation table, which must be a mapping of Unicode ordinals to\n Unicode ordinals, strings, or None.\n\nThe table must implement lookup/indexing via __getitem__, for instance a\ndictionary or list. If this operation raises LookupError, the character is\nleft untouched. Characters mapped to None are deleted.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "table", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 827988759, - "Name": "translate", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a copy of the string converted to uppercase.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 769969899, - "Name": "upper", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Pad a numeric string with zeros on the left, to fill a field of the given width.\n\nThe string is never truncated.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "width", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 774283078, - "Name": "zfill", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 799418, - "Name": "str", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str_iterator", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str_iterator", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "str_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str_iterator" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Private method returning an estimate of len(list(it)).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 358836041, - "Name": "__length_hint__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement next(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1101153034, - "Name": "__next__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return state information for pickling.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -544113923, - "Name": "__reduce__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Set state information for unpickling.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "str_iterator", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "state", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1719806726, - "Name": "__setstate__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "str_iterator", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 1858697299, - "Name": "str_iterator", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Create a module object.\n\nThe name must be a string; the optional doc argument can have any type.", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Implement delattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "module", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 2095540485, - "Name": "__delattr__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "__dir__() -> list\nspecialized dir() implementation", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "module", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:list" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1636169386, - "Name": "__dir__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "module", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Create a module object.\n\nThe name must be a string; the optional doc argument can have any type.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "module", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "module", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return repr(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "module", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1215429388, - "Name": "__repr__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement setattr(self, name, value).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "module", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -736377828, - "Name": "__setattr__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "module", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": "i:dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": null - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": -2131035837, - "Name": "module", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Create a function object.\n\n code\n a code object\n globals\n the globals dictionary\n name\n a string that overrides the name from the code object\n argdefs\n a tuple that specifies the default argument values\n closure\n a tuple that supplies the bindings for free variables", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Call self as a function.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "function", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 782173109, - "Name": "__call__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return an attribute of instance, which is of type owner.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "function", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "instance", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "owner", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:function" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1633516065, - "Name": "__get__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Create a function object.\n\n code\n a code object\n globals\n the globals dictionary\n name\n a string that overrides the name from the code object\n argdefs\n a tuple that specifies the default argument values\n closure\n a tuple that supplies the bindings for free variables", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "function", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "function", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return repr(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "function", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1215429388, - "Name": "__repr__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "function", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [ - { - "Documentation": "", - "ReturnType": "i:dict", - "Attributes": 0, - "Id": 1058045229, - "Name": "__annotations__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 2101485316, - "Name": "__closure__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": "i:object", - "Attributes": 0, - "Id": 794857348, - "Name": "__code__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": -1308361943, - "Name": "__defaults__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": "i:dict", - "Attributes": 0, - "Id": -1338696519, - "Name": "__globals__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": -56184875, - "Name": "__kwdefaults__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Fields": [ - { - "Value": "i:dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": null - }, - { - "Value": null, - "Id": 1097116834, - "Name": "__name__", - "IndexSpan": null - }, - { - "Value": null, - "Id": -1879833807, - "Name": "__qualname__", - "IndexSpan": null - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": -1535808273, - "Name": "function", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Call self as a function.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "wrapper_descriptor", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 782173109, - "Name": "__call__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return an attribute of instance, which is of type owner.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "wrapper_descriptor", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "instance", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "owner", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:wrapper_descriptor" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1633516065, - "Name": "__get__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "wrapper_descriptor", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "wrapper_descriptor", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "wrapper_descriptor", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -544113923, - "Name": "__reduce__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return repr(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "wrapper_descriptor", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1215429388, - "Name": "__repr__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "wrapper_descriptor", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [ - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 1840816120, - "Name": "__objclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Fields": [ - { - "Value": null, - "Id": 1097116834, - "Name": "__name__", - "IndexSpan": null - }, - { - "Value": null, - "Id": -1879833807, - "Name": "__qualname__", - "IndexSpan": null - }, - { - "Value": null, - "Id": 174109373, - "Name": "__text_signature__", - "IndexSpan": null - }, - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": -98573582, - "Name": "wrapper_descriptor", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Call self as a function.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "builtin_function_or_method", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 782173109, - "Name": "__call__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self==value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "builtin_function_or_method", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748372547, - "Name": "__eq__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "builtin_function_or_method", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "builtin_function_or_method", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "builtin_function_or_method", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return hash(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "builtin_function_or_method", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "builtin_function_or_method", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "builtin_function_or_method", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self raise GeneratorExit inside generator.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "generator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 753226817, - "Name": "close", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "generator", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24767519, - "Name": "send", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "generator", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "type", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "traceback", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 768810287, - "Name": "throw", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [ - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 1450385203, - "Name": "gi_code", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 2015125735, - "Name": "gi_frame", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 1663620793, - "Name": "gi_running", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": -1949084879, - "Name": "gi_yieldfrom", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Fields": [ - { - "Value": null, - "Id": 1097116834, - "Name": "__name__", - "IndexSpan": null - }, - { - "Value": null, - "Id": -1879833807, - "Name": "__qualname__", - "IndexSpan": null - }, - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 62112924, - "Name": "generator", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Property attribute.\n\n fget\n function to be used for getting an attribute value\n fset\n function to be used for setting an attribute value\n fdel\n function to be used for del'ing an attribute\n doc\n docstring\n\nTypical use is to define a managed attribute x:\n\nclass C(object):\n def getx(self): return self._x\n def setx(self, value): self._x = value\n def delx(self): del self._x\n x = property(getx, setx, delx, \"I'm the 'x' property.\")\n\nDecorators make defining new properties or modifying existing ones easy:\n\nclass C(object):\n @property\n def x(self):\n \"I am the 'x' property.\"\n return self._x\n @x.setter\n def x(self, value):\n self._x = value\n @x.deleter\n def x(self):\n del self._x", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Delete an attribute of instance.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "property", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "instance", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1041108482, - "Name": "__delete__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return an attribute of instance, which is of type owner.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "property", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "instance", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "owner", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:property" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1633516065, - "Name": "__get__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "property", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Property attribute.\n\n fget\n function to be used for getting an attribute value\n fset\n function to be used for setting an attribute value\n fdel\n function to be used for del'ing an attribute\n doc\n docstring\n\nTypical use is to define a managed attribute x:\n\nclass C(object):\n def getx(self): return self._x\n def setx(self, value): self._x = value\n def delx(self): del self._x\n x = property(getx, setx, delx, \"I'm the 'x' property.\")\n\nDecorators make defining new properties or modifying existing ones easy:\n\nclass C(object):\n @property\n def x(self):\n \"I am the 'x' property.\"\n return self._x\n @x.setter\n def x(self, value):\n self._x = value\n @x.deleter\n def x(self):\n del self._x", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "property", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "property", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Set an attribute of instance to value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "property", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "instance", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1622433813, - "Name": "__set__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "property", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Descriptor to change the deleter on a property.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "property", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "func", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1314572240, - "Name": "deleter", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Descriptor to change the getter on a property.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "property", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "func", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1983396834, - "Name": "getter", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Descriptor to change the setter on a property.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "property", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "func", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1968020650, - "Name": "setter", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [ - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 305214020, - "Name": "__isabstractmethod__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 24379004, - "Name": "fdel", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 24381895, - "Name": "fget", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 24393427, - "Name": "fset", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 385079020, - "Name": "property", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "classmethod(function) -> method\n\nConvert a function to be a class method.\n\nA class method receives the class as implicit first argument,\njust like an instance method receives the instance.\nTo declare a class method, use this idiom:\n\n class C:\n @classmethod\n def f(cls, arg1, arg2, ...):\n ...\n\nIt can be called either on the class (e.g. C.f()) or on an instance\n(e.g. C().f()). The instance is ignored except for its class.\nIf a class method is called for a derived class, the derived class\nobject is passed as the implied first argument.\n\nClass methods are different than C++ or Java static methods.\nIf you want those, see the staticmethod builtin.", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return an attribute of instance, which is of type owner.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "classmethod", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "instance", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "owner", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:classmethod" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1633516065, - "Name": "__get__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "classmethod(function) -> method\n\nConvert a function to be a class method.\n\nA class method receives the class as implicit first argument,\njust like an instance method receives the instance.\nTo declare a class method, use this idiom:\n\n class C:\n @classmethod\n def f(cls, arg1, arg2, ...):\n ...\n\nIt can be called either on the class (e.g. C.f()) or on an instance\n(e.g. C().f()). The instance is ignored except for its class.\nIf a class method is called for a derived class, the derived class\nobject is passed as the implied first argument.\n\nClass methods are different than C++ or Java static methods.\nIf you want those, see the staticmethod builtin.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "classmethod", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "function", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "classmethod", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "classmethod", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [ - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 886581915, - "Name": "__func__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 305214020, - "Name": "__isabstractmethod__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Fields": [ - { - "Value": "i:dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": null - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": -1347789854, - "Name": "classmethod", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "staticmethod(function) -> method\n\nConvert a function to be a static method.\n\nA static method does not receive an implicit first argument.\nTo declare a static method, use this idiom:\n\n class C:\n @staticmethod\n def f(arg1, arg2, ...):\n ...\n\nIt can be called either on the class (e.g. C.f()) or on an instance\n(e.g. C().f()). The instance is ignored except for its class.\n\nStatic methods in Python are similar to those found in Java or C++.\nFor a more advanced concept, see the classmethod builtin.", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return an attribute of instance, which is of type owner.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "staticmethod", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "instance", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "owner", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:staticmethod" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1633516065, - "Name": "__get__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "staticmethod(function) -> method\n\nConvert a function to be a static method.\n\nA static method does not receive an implicit first argument.\nTo declare a static method, use this idiom:\n\n class C:\n @staticmethod\n def f(arg1, arg2, ...):\n ...\n\nIt can be called either on the class (e.g. C.f()) or on an instance\n(e.g. C().f()). The instance is ignored except for its class.\n\nStatic methods in Python are similar to those found in Java or C++.\nFor a more advanced concept, see the classmethod builtin.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "staticmethod", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "function", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "staticmethod", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "staticmethod", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [ - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 886581915, - "Name": "__func__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 305214020, - "Name": "__isabstractmethod__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Fields": [ - { - "Value": "i:dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": null - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": -382457242, - "Name": "staticmethod", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "ellipsis", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "ellipsis", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "ellipsis", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "ellipsis", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -544113923, - "Name": "__reduce__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return repr(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "ellipsis", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1215429388, - "Name": "__repr__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "ellipsis", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 1566923240, - "Name": "ellipsis", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple_iterator", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple_iterator", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "tuple_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple_iterator" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Private method returning an estimate of len(list(it)).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 358836041, - "Name": "__length_hint__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement next(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1101153034, - "Name": "__next__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return state information for pickling.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -544113923, - "Name": "__reduce__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Set state information for unpickling.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "tuple_iterator", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "state", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1719806726, - "Name": "__setstate__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "tuple_iterator", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 1210482396, - "Name": "tuple_iterator", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "list_iterator", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "list_iterator", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "list_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "list_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:list_iterator" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Private method returning an estimate of len(list(it)).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "list_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 358836041, - "Name": "__length_hint__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement next(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "list_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1101153034, - "Name": "__next__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return state information for pickling.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "list_iterator", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -544113923, - "Name": "__reduce__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Set state information for unpickling.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "list_iterator", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "state", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1719806726, - "Name": "__setstate__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "list_iterator", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": -235571144, - "Name": "list_iterator", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return self&value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict_keys", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:dict_keys" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1638804448, - "Name": "__and__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return key in self.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict_keys", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1841774666, - "Name": "__contains__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self==value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict_keys", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748372547, - "Name": "__eq__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict_keys", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict_keys", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict_keys", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict_keys", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "dict_keys", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict_keys", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:dict_keys" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict_keys", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return len(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict_keys", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1628904226, - "Name": "__len__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict_items", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict_items", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict_items", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict_items", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "dict_items", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict_items", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:dict_items" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict_items", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return len(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "dict_items", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1628904226, - "Name": "__len__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self bytearray\nbytearray(string, encoding[, errors]) -> bytearray\nbytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer\nbytearray(int) -> bytes array of size given by the parameter initialized with null bytes\nbytearray() -> empty bytes array\n\nConstruct a mutable bytearray object from:\n - an iterable yielding integers in range(256)\n - a text string encoded using the specified encoding\n - a bytes or a buffer object\n - any object implementing the buffer API.\n - an integer", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return self+value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytearray" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1639102358, - "Name": "__add__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.__alloc__() -> int\n\nReturn the number of bytes actually allocated.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1312536510, - "Name": "__alloc__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return key in self.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1841774666, - "Name": "__contains__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Delete self[key].", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1970845273, - "Name": "__delitem__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self==value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748372547, - "Name": "__eq__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self[key].", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -293179214, - "Name": "__getitem__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement self+=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 953701999, - "Name": "__iadd__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement self*=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965298386, - "Name": "__imul__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "bytearray(iterable_of_ints) -> bytearray\nbytearray(string, encoding[, errors]) -> bytearray\nbytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer\nbytearray(int) -> bytes array of size given by the parameter initialized with null bytes\nbytearray() -> empty bytes array\n\nConstruct a mutable bytearray object from:\n - an iterable yielding integers in range(256)\n - a text string encoded using the specified encoding\n - a bytes or a buffer object\n - any object implementing the buffer API.\n - an integer", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "string", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "encoding", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "errors", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytearray" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return len(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1628904226, - "Name": "__len__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self copy of B\n\nReturn a copy of B with only its first character capitalized (ASCII)\nand the rest lower-cased.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytearray" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -145846717, - "Name": "capitalize", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.center(width[, fillchar]) -> copy of B\n\nReturn B centered in a string of length width. Padding is\ndone using the specified fill character (default is a space).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytearray" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1868701484, - "Name": "center", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Remove all items from the bytearray.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 753216662, - "Name": "clear", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a copy of B.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytearray" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24300556, - "Name": "copy", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.count(sub[, start[, end]]) -> int\n\nReturn the number of non-overlapping occurrences of subsection sub in\nbytes B[start:end]. Optional arguments start and end are interpreted\nas in slice notation.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "x", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 753321816, - "Name": "count", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Decode the bytearray using the codec registered for encoding.\n\n encoding\n The encoding with which to decode the bytearray.\n errors\n The error handling scheme to use for the handling of decoding errors.\n The default is 'strict' meaning that decoding errors raise a\n UnicodeDecodeError. Other possible values are 'ignore' and 'replace'\n as well as any other name registered with codecs.register_error that\n can handle UnicodeDecodeErrors.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "encoding", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "errors", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1896998085, - "Name": "decode", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.endswith(suffix[, start[, end]]) -> bool\n\nReturn True if B ends with the specified suffix, False otherwise.\nWith optional start, test B beginning at that position.\nWith optional end, stop comparing B at that position.\nsuffix can also be a tuple of bytes to try.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "suffix", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1172635435, - "Name": "endswith", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.expandtabs(tabsize=8) -> copy of B\n\nReturn a copy of B where all tab characters are expanded using spaces.\nIf tabsize is not given, a tab size of 8 characters is assumed.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "tabsize", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytearray" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -2134490001, - "Name": "expandtabs", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Append all the items from the iterator or sequence to the end of the bytearray.\n\n iterable_of_ints\n The iterable of items to append.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "iterable_of_ints", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1943671281, - "Name": "extend", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.find(sub[, start[, end]]) -> int\n\nReturn the lowest index in B where subsection sub is found,\nsuch that sub is contained within B[start,end]. Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sub", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24384080, - "Name": "find", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Create a bytearray object from a string of hexadecimal numbers.\n\nSpaces between two numbers are accepted.\nExample: bytearray.fromhex('B9 01EF') -> bytearray(b'\\\\xb9\\\\x01\\\\xef')", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "type", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "string", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 835611450, - "Name": "fromhex", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.hex() -> string\n\nCreate a string of hexadecimal numbers from a bytearray object.\nExample: bytearray([0xb9, 0x01, 0xef]).hex() -> 'b901ef'.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 788388, - "Name": "hex", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.index(sub[, start[, end]]) -> int\n\nReturn the lowest index in B where subsection sub is found,\nsuch that sub is contained within B[start,end]. Optional\narguments start and end are interpreted as in slice notation.\n\nRaises ValueError when the subsection is not found.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "v", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 758816539, - "Name": "index", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Insert a single item into the bytearray before the given index.\n\n index\n The index where the value is to be inserted.\n item\n The item to be inserted.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "index", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "item", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 2048923024, - "Name": "insert", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.isalnum() -> bool\n\nReturn True if all characters in B are alphanumeric\nand there is at least one character in B, False otherwise.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -781168486, - "Name": "isalnum", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.isalpha() -> bool\n\nReturn True if all characters in B are alphabetic\nand there is at least one character in B, False otherwise.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -781166979, - "Name": "isalpha", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.isascii() -> bool\n\nReturn True if B is empty or all characters in B are ASCII,\nFalse otherwise.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -780970896, - "Name": "isascii", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.isdigit() -> bool\n\nReturn True if all characters in B are digits\nand there is at least one character in B, False otherwise.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -778494388, - "Name": "isdigit", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.islower() -> bool\n\nReturn True if all cased characters in B are lowercase and there is\nat least one cased character in B, False otherwise.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -770912224, - "Name": "islower", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.isspace() -> bool\n\nReturn True if all characters in B are whitespace\nand there is at least one character in B, False otherwise.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -764439003, - "Name": "isspace", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.istitle() -> bool\n\nReturn True if B is a titlecased string and there is at least one\ncharacter in B, i.e. uppercase characters may only follow uncased\ncharacters and lowercase characters only cased ones. Return False\notherwise.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -763705481, - "Name": "istitle", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.isupper() -> bool\n\nReturn True if all cased characters in B are uppercase and there is\nat least one cased character in B, False otherwise.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -762577471, - "Name": "isupper", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Concatenate any number of bytes/bytearray objects.\n\nThe bytearray whose method is called is inserted in between each pair.\n\nThe result is returned as a new bytearray object.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "iterable_of_bytes", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24508865, - "Name": "join", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.ljust(width[, fillchar]) -> copy of B\n\nReturn B left justified in a string of length width. Padding is\ndone using the specified fill character (default is a space).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytearray" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 761484705, - "Name": "ljust", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.lower() -> copy of B\n\nReturn a copy of B with all ASCII characters converted to lowercase.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytearray" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 761635146, - "Name": "lower", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Strip leading bytes contained in the argument.\n\nIf the argument is omitted or None, strip leading ASCII whitespace.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "bytes", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytearray" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 2139470083, - "Name": "lstrip", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a translation table useable for the bytes or bytearray translate method.\n\nThe returned table will be one where each byte in frm is mapped to the byte at\nthe same position in to.\n\nThe bytes objects frm and to must be of the same length.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "frm", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "to", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1060805443, - "Name": "maketrans", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Partition the bytearray into three parts using the given separator.\n\nThis will search for the separator sep in the bytearray. If the separator is\nfound, returns a 3-tuple containing the part before the separator, the\nseparator itself, and the part after it as new bytearray objects.\n\nIf the separator is not found, returns a 3-tuple containing the copy of the\noriginal bytearray object and two empty bytearray objects.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sep", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -2024653645, - "Name": "partition", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Remove and return a single item from B.\n\n index\n The index from where to remove the item.\n -1 (the default value) means remove the last item.\n\nIf no index argument is given, will pop the last item.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "index", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 796378, - "Name": "pop", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Remove the first occurrence of a value in the bytearray.\n\n value\n The value to remove.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1996862629, - "Name": "remove", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a copy with all occurrences of substring old replaced by new.\n\n count\n Maximum number of occurrences to replace.\n -1 (the default value) means replace all occurrences.\n\nIf the optional argument count is given, only the first count occurrences are\nreplaced.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "old", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "new", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "count", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytearray" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1770538307, - "Name": "replace", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Reverse the order of the values in B in place.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1765188885, - "Name": "reverse", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.rfind(sub[, start[, end]]) -> int\n\nReturn the highest index in B where subsection sub is found,\nsuch that sub is contained within B[start,end]. Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sub", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 766894964, - "Name": "rfind", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.rindex(sub[, start[, end]]) -> int\n\nReturn the highest index in B where subsection sub is found,\nsuch that sub is contained within B[start,end]. Optional\narguments start and end are interpreted as in slice notation.\n\nRaise ValueError when the subsection is not found.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sub", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1993149833, - "Name": "rindex", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.rjust(width[, fillchar]) -> copy of B\n\nReturn B right justified in a string of length width. Padding is\ndone using the specified fill character (default is a space)", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytearray" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 767025831, - "Name": "rjust", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Partition the bytearray into three parts using the given separator.\n\nThis will search for the separator sep in the bytearray, starting at the end.\nIf the separator is found, returns a 3-tuple containing the part before the\nseparator, the separator itself, and the part after it as new bytearray\nobjects.\n\nIf the separator is not found, returns a 3-tuple containing two empty bytearray\nobjects and the copy of the original bytearray object.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sep", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1107721713, - "Name": "rpartition", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a list of the sections in the bytearray, using sep as the delimiter.\n\n sep\n The delimiter according which to split the bytearray.\n None (the default value) means split on ASCII whitespace characters\n (space, tab, return, newline, formfeed, vertical tab).\n maxsplit\n Maximum number of splits to do.\n -1 (the default value) means no limit.\n\nSplitting is done starting at the end of the bytearray and working to the front.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sep", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "maxsplit", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:list" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1983847233, - "Name": "rsplit", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Strip trailing bytes contained in the argument.\n\nIf the argument is omitted or None, strip trailing ASCII whitespace.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "bytes", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytearray" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1983722307, - "Name": "rstrip", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a list of the sections in the bytearray, using sep as the delimiter.\n\n sep\n The delimiter according which to split the bytearray.\n None (the default value) means split on ASCII whitespace characters\n (space, tab, return, newline, formfeed, vertical tab).\n maxsplit\n Maximum number of splits to do.\n -1 (the default value) means no limit.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "sep", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "maxsplit", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:list" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 768119139, - "Name": "split", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a list of the lines in the bytearray, breaking at line boundaries.\n\nLine breaks are not included in the resulting list unless keepends is given and\ntrue.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "keepends", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:list" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1291658108, - "Name": "splitlines", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.startswith(prefix[, start[, end]]) -> bool\n\nReturn True if B starts with the specified prefix, False otherwise.\nWith optional start, test B beginning at that position.\nWith optional end, stop comparing B at that position.\nprefix can also be a tuple of bytes to try.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "prefix", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "end", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 65206254, - "Name": "startswith", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Strip leading and trailing bytes contained in the argument.\n\nIf the argument is omitted or None, strip leading and trailing ASCII whitespace.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "bytes", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytearray" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 768244065, - "Name": "strip", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.swapcase() -> copy of B\n\nReturn a copy of B with uppercase ASCII characters converted\nto lowercase ASCII and vice versa.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytearray" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1060209754, - "Name": "swapcase", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.title() -> copy of B\n\nReturn a titlecased version of B, i.e. ASCII words start with uppercase\ncharacters, all remaining cased characters have lowercase.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytearray" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 768841889, - "Name": "title", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a copy with each character mapped by the given translation table.\n\n table\n Translation table, which must be a bytes object of length 256.\n\nAll characters occurring in the optional argument delete are removed.\nThe remaining characters are mapped through the given translation table.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "table", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "delete", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 827988759, - "Name": "translate", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.upper() -> copy of B\n\nReturn a copy of B with all ASCII characters converted to uppercase.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytearray" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 769969899, - "Name": "upper", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "B.zfill(width) -> copy of B\n\nPad a numeric string B with zeros on the left, to fill a field\nof the specified width. B is never truncated.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "bytearray", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "width", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bytearray" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 774283078, - "Name": "zfill", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": null - }, - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 2020778010, - "Name": "bytearray", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return an enumerate object.\n\n iterable\n an object supporting iteration\n\nThe enumerate object yields pairs containing a count (from start, which\ndefaults to zero) and a value yielded by the iterable argument.\n\nenumerate is useful for obtaining an indexed list:\n (0, seq[0]), (1, seq[1]), (2, seq[2]), ...", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "enumerate", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return an enumerate object.\n\n iterable\n an object supporting iteration\n\nThe enumerate object yields pairs containing a count (from start, which\ndefaults to zero) and a value yielded by the iterable argument.\n\nenumerate is useful for obtaining an indexed list:\n (0, seq[0]), (1, seq[1]), (2, seq[2]), ...", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "enumerate", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "enumerate", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "enumerate", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:enumerate" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement next(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "enumerate", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1101153034, - "Name": "__next__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return state information for pickling.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "enumerate", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -544113923, - "Name": "__reduce__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "enumerate", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 22552621, - "Name": "enumerate", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "filter(function or None, iterable) --> filter object\n\nReturn an iterator yielding those items of iterable for which function(item)\nis true. If function is None, return the items that are true.", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "filter", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "filter(function or None, iterable) --> filter object\n\nReturn an iterator yielding those items of iterable for which function(item)\nis true. If function is None, return the items that are true.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "filter", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "functionorNone", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "iterable", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "filter", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "filter", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:filter" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement next(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "filter", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1101153034, - "Name": "__next__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return state information for pickling.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "filter", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -544113923, - "Name": "__reduce__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "filter", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 1958223439, - "Name": "filter", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "map(func, *iterables) --> map object\n\nMake an iterator that computes the function using arguments from\neach of the iterables. Stops when the shortest iterable is exhausted.", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "map", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "map(func, *iterables) --> map object\n\nMake an iterator that computes the function using arguments from\neach of the iterables. Stops when the shortest iterable is exhausted.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "map", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "func", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "iterables", - "Type": null, - "DefaultValue": null, - "Kind": 1 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "map", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "map", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:map" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement next(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "map", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1101153034, - "Name": "__next__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return state information for pickling.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "map", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -544113923, - "Name": "__reduce__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "map", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 793061, - "Name": "map", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Create a new memoryview object which references the given object.", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Delete self[key].", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "memoryview", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1970845273, - "Name": "__delitem__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "memoryview", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:memoryview" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 631946913, - "Name": "__enter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self==value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "memoryview", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748372547, - "Name": "__eq__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "memoryview", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 860590709, - "Name": "__exit__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "memoryview", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "memoryview", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self[key].", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "memoryview", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -293179214, - "Name": "__getitem__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "memoryview", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return hash(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "memoryview", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Create a new memoryview object which references the given object.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "memoryview", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "memoryview", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "memoryview", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return len(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "memoryview", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1628904226, - "Name": "__len__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "slice", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "slice", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "slice", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "slice(stop)\nslice(start, stop[, step])\n\nCreate a slice object. This is used for extended slicing (e.g. a[0:10:2]).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "slice", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "start", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "stop", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "step", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "slice", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "slice", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self (start, stop, stride)\n\nAssuming a sequence of length len, calculate the start and stop\nindices, and the stride length of the extended slice described by\nS. Out of bounds indices are clipped in a manner consistent with the\nhandling of normal slices.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "slice", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -921644112, - "Name": "indices", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [ - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 768228011, - "Name": "start", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 24781667, - "Name": "step", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 24781977, - "Name": "stop", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Fields": [ - { - "Value": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": null - }, - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 767996891, - "Name": "slice", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "super() -> same as super(__class__, )\nsuper(type) -> unbound super object\nsuper(type, obj) -> bound super object; requires isinstance(obj, type)\nsuper(type, type2) -> bound super object; requires issubclass(type2, type)\nTypical use to call a cooperative superclass method:\nclass C(B):\n def meth(self, arg):\n super().meth(arg)\nThis works for class methods too:\nclass C(B):\n @classmethod\n def cmeth(cls, arg):\n super().cmeth(arg)\n", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return an attribute of instance, which is of type owner.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "super", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "instance", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "owner", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:super" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1633516065, - "Name": "__get__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "super", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "super() -> same as super(__class__, )\nsuper(type) -> unbound super object\nsuper(type, obj) -> bound super object; requires isinstance(obj, type)\nsuper(type, type2) -> bound super object; requires issubclass(type2, type)\nTypical use to call a cooperative superclass method:\nclass C(B):\n def meth(self, arg):\n super().meth(arg)\nThis works for class methods too:\nclass C(B):\n @classmethod\n def cmeth(cls, arg):\n super().cmeth(arg)\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "super", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "type", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "type2", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "super", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return repr(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "super", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1215429388, - "Name": "__repr__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "super", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [ - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 1243927843, - "Name": "__self__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 2069653788, - "Name": "__self_class__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "", - "ReturnType": null, - "Attributes": 0, - "Id": 185188451, - "Name": "__thisclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 768271812, - "Name": "super", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "zip(iter1 [,iter2 [...]]) --> zip object\n\nReturn a zip object whose .__next__() method returns a tuple where\nthe i-th element comes from the i-th iterable argument. The .__next__()\nmethod continues until the shortest iterable in the argument sequence\nis exhausted and then it raises StopIteration.", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "zip", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "zip(iter1 [,iter2 [...]]) --> zip object\n\nReturn a zip object whose .__next__() method returns a tuple where\nthe i-th element comes from the i-th iterable argument. The .__next__()\nmethod continues until the shortest iterable in the argument sequence\nis exhausted and then it raises StopIteration.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "zip", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "zip", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "zip", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:zip" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement next(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "zip", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1101153034, - "Name": "__next__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return state information for pickling.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "zip", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -544113923, - "Name": "__reduce__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "zip", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 805802, - "Name": "zip", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "type(object_or_name, bases, dict)\ntype(object) -> the object's type\ntype(name, bases, dict) -> a new type", - "Bases": [ - "object" - ], - "Methods": [ - { - "Documentation": "Call self as a function.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "type", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 782173109, - "Name": "__call__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement delattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "type", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 2095540485, - "Name": "__delattr__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Specialized __dir__ implementation for types.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "type", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:list" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1636169386, - "Name": "__dir__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "type", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "type(object_or_name, bases, dict)\ntype(object) -> the object's type\ntype(name, bases, dict) -> a new type", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "type", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "object_or_name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "bases", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "dict", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "type", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Check if an object is an instance.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "type", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "instance", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1213275748, - "Name": "__instancecheck__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "__prepare__() -> dict\nused to create the namespace for the class statement", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "type", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "bases", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "kwds", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1556881104, - "Name": "__prepare__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return repr(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "type", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1215429388, - "Name": "__repr__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement setattr(self, name, value).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "type", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -736377828, - "Name": "__setattr__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return memory consumption of the type object.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "type", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1069167279, - "Name": "__sizeof__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Check if a class is a subclass.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "type", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -25004647, - "Name": "__subclasscheck__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return a list of immediate subclasses.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "type", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1804067837, - "Name": "__subclasses__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented. If it returns\nNotImplemented, the normal algorithm is used. Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "type", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "subclass", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1374911630, - "Name": "__subclasshook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Properties": [], - "Fields": [ - { - "Value": null, - "Id": -1388753224, - "Name": "__basicsize__", - "IndexSpan": null - }, - { - "Value": "i:dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": null - }, - { - "Value": null, - "Id": -198224608, - "Name": "__dictoffset__", - "IndexSpan": null - }, - { - "Value": null, - "Id": 1444705936, - "Name": "__flags__", - "IndexSpan": null - }, - { - "Value": null, - "Id": 919460331, - "Name": "__itemsize__", - "IndexSpan": null - }, - { - "Value": "i:tuple", - "Id": -1627592461, - "Name": "__mro__", - "IndexSpan": null - }, - { - "Value": null, - "Id": 1097116834, - "Name": "__name__", - "IndexSpan": null - }, - { - "Value": null, - "Id": -1879833807, - "Name": "__qualname__", - "IndexSpan": null - }, - { - "Value": null, - "Id": 174109373, - "Name": "__text_signature__", - "IndexSpan": null - }, - { - "Value": null, - "Id": 1521523639, - "Name": "__weakrefoffset__", - "IndexSpan": null - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "GenericParameters": null, - "InnerClasses": [], - "Id": 24816593, - "Name": "type", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "NewLines": [ - { - "EndIndex": 35, - "Kind": 3 - }, - { - "EndIndex": 71, - "Kind": 3 - }, - { - "EndIndex": 113, - "Kind": 3 - }, - { - "EndIndex": 127, - "Kind": 3 - }, - { - "EndIndex": 133, - "Kind": 3 - }, - { - "EndIndex": 151, - "Kind": 3 - }, - { - "EndIndex": 184, - "Kind": 3 - }, - { - "EndIndex": 335, - "Kind": 3 - }, - { - "EndIndex": 356, - "Kind": 3 - }, - { - "EndIndex": 362, - "Kind": 3 - }, - { - "EndIndex": 389, - "Kind": 3 - }, - { - "EndIndex": 419, - "Kind": 3 - }, - { - "EndIndex": 425, - "Kind": 3 - }, - { - "EndIndex": 450, - "Kind": 3 - }, - { - "EndIndex": 480, - "Kind": 3 - }, - { - "EndIndex": 499, - "Kind": 3 - }, - { - "EndIndex": 505, - "Kind": 3 - }, - { - "EndIndex": 523, - "Kind": 3 - }, - { - "EndIndex": 565, - "Kind": 3 - }, - { - "EndIndex": 891, - "Kind": 3 - }, - { - "EndIndex": 913, - "Kind": 3 - }, - { - "EndIndex": 919, - "Kind": 3 - }, - { - "EndIndex": 921, - "Kind": 3 - }, - { - "EndIndex": 941, - "Kind": 3 - }, - { - "EndIndex": 958, - "Kind": 3 - }, - { - "EndIndex": 986, - "Kind": 3 - }, - { - "EndIndex": 988, - "Kind": 3 - }, - { - "EndIndex": 1009, - "Kind": 3 - }, - { - "EndIndex": 1044, - "Kind": 3 - }, - { - "EndIndex": 1046, - "Kind": 3 - }, - { - "EndIndex": 1061, - "Kind": 3 - }, - { - "EndIndex": 1087, - "Kind": 3 - }, - { - "EndIndex": 1111, - "Kind": 3 - }, - { - "EndIndex": 1145, - "Kind": 3 - }, - { - "EndIndex": 1187, - "Kind": 3 - }, - { - "EndIndex": 1208, - "Kind": 3 - }, - { - "EndIndex": 1214, - "Kind": 3 - }, - { - "EndIndex": 1238, - "Kind": 3 - }, - { - "EndIndex": 1279, - "Kind": 3 - }, - { - "EndIndex": 1300, - "Kind": 3 - }, - { - "EndIndex": 1306, - "Kind": 3 - }, - { - "EndIndex": 1336, - "Kind": 3 - }, - { - "EndIndex": 1367, - "Kind": 3 - }, - { - "EndIndex": 1389, - "Kind": 3 - }, - { - "EndIndex": 1395, - "Kind": 3 - }, - { - "EndIndex": 1435, - "Kind": 3 - }, - { - "EndIndex": 1472, - "Kind": 3 - }, - { - "EndIndex": 1491, - "Kind": 3 - }, - { - "EndIndex": 1497, - "Kind": 3 - }, - { - "EndIndex": 1527, - "Kind": 3 - }, - { - "EndIndex": 1558, - "Kind": 3 - }, - { - "EndIndex": 1580, - "Kind": 3 - }, - { - "EndIndex": 1586, - "Kind": 3 - }, - { - "EndIndex": 1625, - "Kind": 3 - }, - { - "EndIndex": 1664, - "Kind": 3 - }, - { - "EndIndex": 1678, - "Kind": 3 - }, - { - "EndIndex": 1684, - "Kind": 3 - }, - { - "EndIndex": 1714, - "Kind": 3 - }, - { - "EndIndex": 1744, - "Kind": 3 - }, - { - "EndIndex": 1766, - "Kind": 3 - }, - { - "EndIndex": 1772, - "Kind": 3 - }, - { - "EndIndex": 1797, - "Kind": 3 - }, - { - "EndIndex": 1827, - "Kind": 3 - }, - { - "EndIndex": 1845, - "Kind": 3 - }, - { - "EndIndex": 1851, - "Kind": 3 - }, - { - "EndIndex": 1893, - "Kind": 3 - }, - { - "EndIndex": 1923, - "Kind": 3 - }, - { - "EndIndex": 1937, - "Kind": 3 - }, - { - "EndIndex": 1943, - "Kind": 3 - }, - { - "EndIndex": 1961, - "Kind": 3 - }, - { - "EndIndex": 1994, - "Kind": 3 - }, - { - "EndIndex": 2145, - "Kind": 3 - }, - { - "EndIndex": 2166, - "Kind": 3 - }, - { - "EndIndex": 2172, - "Kind": 3 - }, - { - "EndIndex": 2202, - "Kind": 3 - }, - { - "EndIndex": 2233, - "Kind": 3 - }, - { - "EndIndex": 2255, - "Kind": 3 - }, - { - "EndIndex": 2261, - "Kind": 3 - }, - { - "EndIndex": 2291, - "Kind": 3 - }, - { - "EndIndex": 2321, - "Kind": 3 - }, - { - "EndIndex": 2343, - "Kind": 3 - }, - { - "EndIndex": 2349, - "Kind": 3 - }, - { - "EndIndex": 2379, - "Kind": 3 - }, - { - "EndIndex": 2410, - "Kind": 3 - }, - { - "EndIndex": 2432, - "Kind": 3 - }, - { - "EndIndex": 2438, - "Kind": 3 - }, - { - "EndIndex": 2465, - "Kind": 3 - }, - { - "EndIndex": 2495, - "Kind": 3 - }, - { - "EndIndex": 2525, - "Kind": 3 - }, - { - "EndIndex": 2531, - "Kind": 3 - }, - { - "EndIndex": 2571, - "Kind": 3 - }, - { - "EndIndex": 2601, - "Kind": 3 - }, - { - "EndIndex": 2631, - "Kind": 3 - }, - { - "EndIndex": 2637, - "Kind": 3 - }, - { - "EndIndex": 2662, - "Kind": 3 - }, - { - "EndIndex": 2692, - "Kind": 3 - }, - { - "EndIndex": 2711, - "Kind": 3 - }, - { - "EndIndex": 2717, - "Kind": 3 - }, - { - "EndIndex": 2758, - "Kind": 3 - }, - { - "EndIndex": 2807, - "Kind": 3 - }, - { - "EndIndex": 2828, - "Kind": 3 - }, - { - "EndIndex": 2834, - "Kind": 3 - }, - { - "EndIndex": 2861, - "Kind": 3 - }, - { - "EndIndex": 2908, - "Kind": 3 - }, - { - "EndIndex": 2926, - "Kind": 3 - }, - { - "EndIndex": 2932, - "Kind": 3 - }, - { - "EndIndex": 2956, - "Kind": 3 - }, - { - "EndIndex": 2985, - "Kind": 3 - }, - { - "EndIndex": 3004, - "Kind": 3 - }, - { - "EndIndex": 3010, - "Kind": 3 - }, - { - "EndIndex": 3028, - "Kind": 3 - }, - { - "EndIndex": 3070, - "Kind": 3 - }, - { - "EndIndex": 3396, - "Kind": 3 - }, - { - "EndIndex": 3418, - "Kind": 3 - }, - { - "EndIndex": 3424, - "Kind": 3 - }, - { - "EndIndex": 3426, - "Kind": 3 - }, - { - "EndIndex": 3447, - "Kind": 3 - }, - { - "EndIndex": 3468, - "Kind": 3 - }, - { - "EndIndex": 3583, - "Kind": 3 - }, - { - "EndIndex": 3608, - "Kind": 3 - }, - { - "EndIndex": 3628, - "Kind": 3 - }, - { - "EndIndex": 3653, - "Kind": 3 - }, - { - "EndIndex": 3695, - "Kind": 3 - }, - { - "EndIndex": 3731, - "Kind": 3 - }, - { - "EndIndex": 3753, - "Kind": 3 - }, - { - "EndIndex": 3759, - "Kind": 3 - }, - { - "EndIndex": 3781, - "Kind": 3 - }, - { - "EndIndex": 3815, - "Kind": 3 - }, - { - "EndIndex": 3857, - "Kind": 3 - }, - { - "EndIndex": 3878, - "Kind": 3 - }, - { - "EndIndex": 3884, - "Kind": 3 - }, - { - "EndIndex": 3903, - "Kind": 3 - }, - { - "EndIndex": 3929, - "Kind": 3 - }, - { - "EndIndex": 3953, - "Kind": 3 - }, - { - "EndIndex": 4010, - "Kind": 3 - }, - { - "EndIndex": 4031, - "Kind": 3 - }, - { - "EndIndex": 4037, - "Kind": 3 - }, - { - "EndIndex": 4066, - "Kind": 3 - }, - { - "EndIndex": 4105, - "Kind": 3 - }, - { - "EndIndex": 4144, - "Kind": 3 - }, - { - "EndIndex": 4158, - "Kind": 3 - }, - { - "EndIndex": 4164, - "Kind": 3 - }, - { - "EndIndex": 4218, - "Kind": 3 - }, - { - "EndIndex": 4337, - "Kind": 3 - }, - { - "EndIndex": 4351, - "Kind": 3 - }, - { - "EndIndex": 4357, - "Kind": 3 - }, - { - "EndIndex": 4375, - "Kind": 3 - }, - { - "EndIndex": 4408, - "Kind": 3 - }, - { - "EndIndex": 4559, - "Kind": 3 - }, - { - "EndIndex": 4580, - "Kind": 3 - }, - { - "EndIndex": 4586, - "Kind": 3 - }, - { - "EndIndex": 4630, - "Kind": 3 - }, - { - "EndIndex": 4676, - "Kind": 3 - }, - { - "EndIndex": 4698, - "Kind": 3 - }, - { - "EndIndex": 4704, - "Kind": 3 - }, - { - "EndIndex": 4727, - "Kind": 3 - }, - { - "EndIndex": 4745, - "Kind": 3 - }, - { - "EndIndex": 4768, - "Kind": 3 - }, - { - "EndIndex": 4786, - "Kind": 3 - }, - { - "EndIndex": 4834, - "Kind": 3 - }, - { - "EndIndex": 4921, - "Kind": 3 - }, - { - "EndIndex": 4942, - "Kind": 3 - }, - { - "EndIndex": 4948, - "Kind": 3 - }, - { - "EndIndex": 4975, - "Kind": 3 - }, - { - "EndIndex": 5000, - "Kind": 3 - }, - { - "EndIndex": 5030, - "Kind": 3 - }, - { - "EndIndex": 5049, - "Kind": 3 - }, - { - "EndIndex": 5055, - "Kind": 3 - }, - { - "EndIndex": 5096, - "Kind": 3 - }, - { - "EndIndex": 5145, - "Kind": 3 - }, - { - "EndIndex": 5166, - "Kind": 3 - }, - { - "EndIndex": 5172, - "Kind": 3 - }, - { - "EndIndex": 5199, - "Kind": 3 - }, - { - "EndIndex": 5256, - "Kind": 3 - }, - { - "EndIndex": 5274, - "Kind": 3 - }, - { - "EndIndex": 5280, - "Kind": 3 - }, - { - "EndIndex": 5324, - "Kind": 3 - }, - { - "EndIndex": 5367, - "Kind": 3 - }, - { - "EndIndex": 5389, - "Kind": 3 - }, - { - "EndIndex": 5395, - "Kind": 3 - }, - { - "EndIndex": 5426, - "Kind": 3 - }, - { - "EndIndex": 5476, - "Kind": 3 - }, - { - "EndIndex": 5499, - "Kind": 3 - }, - { - "EndIndex": 5505, - "Kind": 3 - }, - { - "EndIndex": 5523, - "Kind": 3 - }, - { - "EndIndex": 5565, - "Kind": 3 - }, - { - "EndIndex": 5891, - "Kind": 3 - }, - { - "EndIndex": 5913, - "Kind": 3 - }, - { - "EndIndex": 5919, - "Kind": 3 - }, - { - "EndIndex": 5950, - "Kind": 3 - }, - { - "EndIndex": 5979, - "Kind": 3 - }, - { - "EndIndex": 5999, - "Kind": 3 - }, - { - "EndIndex": 6051, - "Kind": 3 - }, - { - "EndIndex": 6080, - "Kind": 3 - }, - { - "EndIndex": 6086, - "Kind": 3 - }, - { - "EndIndex": 6088, - "Kind": 3 - }, - { - "EndIndex": 6105, - "Kind": 3 - }, - { - "EndIndex": 6125, - "Kind": 3 - }, - { - "EndIndex": 6751, - "Kind": 3 - }, - { - "EndIndex": 6775, - "Kind": 3 - }, - { - "EndIndex": 6796, - "Kind": 3 - }, - { - "EndIndex": 6818, - "Kind": 3 - }, - { - "EndIndex": 6824, - "Kind": 3 - }, - { - "EndIndex": 6855, - "Kind": 3 - }, - { - "EndIndex": 6885, - "Kind": 3 - }, - { - "EndIndex": 6907, - "Kind": 3 - }, - { - "EndIndex": 6913, - "Kind": 3 - }, - { - "EndIndex": 6944, - "Kind": 3 - }, - { - "EndIndex": 6974, - "Kind": 3 - }, - { - "EndIndex": 6996, - "Kind": 3 - }, - { - "EndIndex": 7002, - "Kind": 3 - }, - { - "EndIndex": 7027, - "Kind": 3 - }, - { - "EndIndex": 7048, - "Kind": 3 - }, - { - "EndIndex": 7070, - "Kind": 3 - }, - { - "EndIndex": 7076, - "Kind": 3 - }, - { - "EndIndex": 7101, - "Kind": 3 - }, - { - "EndIndex": 7151, - "Kind": 3 - }, - { - "EndIndex": 7173, - "Kind": 3 - }, - { - "EndIndex": 7179, - "Kind": 3 - }, - { - "EndIndex": 7200, - "Kind": 3 - }, - { - "EndIndex": 7234, - "Kind": 3 - }, - { - "EndIndex": 7273, - "Kind": 3 - }, - { - "EndIndex": 7296, - "Kind": 3 - }, - { - "EndIndex": 7302, - "Kind": 3 - }, - { - "EndIndex": 7332, - "Kind": 3 - }, - { - "EndIndex": 7363, - "Kind": 3 - }, - { - "EndIndex": 7385, - "Kind": 3 - }, - { - "EndIndex": 7391, - "Kind": 3 - }, - { - "EndIndex": 7417, - "Kind": 3 - }, - { - "EndIndex": 7440, - "Kind": 3 - }, - { - "EndIndex": 7460, - "Kind": 3 - }, - { - "EndIndex": 7466, - "Kind": 3 - }, - { - "EndIndex": 7492, - "Kind": 3 - }, - { - "EndIndex": 7540, - "Kind": 3 - }, - { - "EndIndex": 7562, - "Kind": 3 - }, - { - "EndIndex": 7568, - "Kind": 3 - }, - { - "EndIndex": 7604, - "Kind": 3 - }, - { - "EndIndex": 7635, - "Kind": 3 - }, - { - "EndIndex": 7653, - "Kind": 3 - }, - { - "EndIndex": 7659, - "Kind": 3 - }, - { - "EndIndex": 7699, - "Kind": 3 - }, - { - "EndIndex": 7718, - "Kind": 3 - }, - { - "EndIndex": 7724, - "Kind": 3 - }, - { - "EndIndex": 7754, - "Kind": 3 - }, - { - "EndIndex": 7785, - "Kind": 3 - }, - { - "EndIndex": 7807, - "Kind": 3 - }, - { - "EndIndex": 7813, - "Kind": 3 - }, - { - "EndIndex": 7852, - "Kind": 3 - }, - { - "EndIndex": 7891, - "Kind": 3 - }, - { - "EndIndex": 7905, - "Kind": 3 - }, - { - "EndIndex": 7911, - "Kind": 3 - }, - { - "EndIndex": 7942, - "Kind": 3 - }, - { - "EndIndex": 7961, - "Kind": 3 - }, - { - "EndIndex": 7967, - "Kind": 3 - }, - { - "EndIndex": 7997, - "Kind": 3 - }, - { - "EndIndex": 8027, - "Kind": 3 - }, - { - "EndIndex": 8049, - "Kind": 3 - }, - { - "EndIndex": 8055, - "Kind": 3 - }, - { - "EndIndex": 8080, - "Kind": 3 - }, - { - "EndIndex": 8110, - "Kind": 3 - }, - { - "EndIndex": 8128, - "Kind": 3 - }, - { - "EndIndex": 8134, - "Kind": 3 - }, - { - "EndIndex": 8160, - "Kind": 3 - }, - { - "EndIndex": 8261, - "Kind": 3 - }, - { - "EndIndex": 8279, - "Kind": 3 - }, - { - "EndIndex": 8285, - "Kind": 3 - }, - { - "EndIndex": 8322, - "Kind": 3 - }, - { - "EndIndex": 8952, - "Kind": 3 - }, - { - "EndIndex": 8966, - "Kind": 3 - }, - { - "EndIndex": 8972, - "Kind": 3 - }, - { - "EndIndex": 8990, - "Kind": 3 - }, - { - "EndIndex": 9023, - "Kind": 3 - }, - { - "EndIndex": 9174, - "Kind": 3 - }, - { - "EndIndex": 9195, - "Kind": 3 - }, - { - "EndIndex": 9201, - "Kind": 3 - }, - { - "EndIndex": 9225, - "Kind": 3 - }, - { - "EndIndex": 9246, - "Kind": 3 - }, - { - "EndIndex": 9264, - "Kind": 3 - }, - { - "EndIndex": 9270, - "Kind": 3 - }, - { - "EndIndex": 9297, - "Kind": 3 - }, - { - "EndIndex": 9314, - "Kind": 3 - }, - { - "EndIndex": 9336, - "Kind": 3 - }, - { - "EndIndex": 9342, - "Kind": 3 - }, - { - "EndIndex": 9372, - "Kind": 3 - }, - { - "EndIndex": 9403, - "Kind": 3 - }, - { - "EndIndex": 9425, - "Kind": 3 - }, - { - "EndIndex": 9431, - "Kind": 3 - }, - { - "EndIndex": 9465, - "Kind": 3 - }, - { - "EndIndex": 9496, - "Kind": 3 - }, - { - "EndIndex": 9518, - "Kind": 3 - }, - { - "EndIndex": 9524, - "Kind": 3 - }, - { - "EndIndex": 9554, - "Kind": 3 - }, - { - "EndIndex": 9584, - "Kind": 3 - }, - { - "EndIndex": 9606, - "Kind": 3 - }, - { - "EndIndex": 9612, - "Kind": 3 - }, - { - "EndIndex": 9643, - "Kind": 3 - }, - { - "EndIndex": 9673, - "Kind": 3 - }, - { - "EndIndex": 9695, - "Kind": 3 - }, - { - "EndIndex": 9701, - "Kind": 3 - }, - { - "EndIndex": 9732, - "Kind": 3 - }, - { - "EndIndex": 9762, - "Kind": 3 - }, - { - "EndIndex": 9784, - "Kind": 3 - }, - { - "EndIndex": 9790, - "Kind": 3 - }, - { - "EndIndex": 9820, - "Kind": 3 - }, - { - "EndIndex": 9851, - "Kind": 3 - }, - { - "EndIndex": 9873, - "Kind": 3 - }, - { - "EndIndex": 9879, - "Kind": 3 - }, - { - "EndIndex": 9903, - "Kind": 3 - }, - { - "EndIndex": 9920, - "Kind": 3 - }, - { - "EndIndex": 9942, - "Kind": 3 - }, - { - "EndIndex": 9948, - "Kind": 3 - }, - { - "EndIndex": 9978, - "Kind": 3 - }, - { - "EndIndex": 10008, - "Kind": 3 - }, - { - "EndIndex": 10030, - "Kind": 3 - }, - { - "EndIndex": 10036, - "Kind": 3 - }, - { - "EndIndex": 10060, - "Kind": 3 - }, - { - "EndIndex": 10077, - "Kind": 3 - }, - { - "EndIndex": 10099, - "Kind": 3 - }, - { - "EndIndex": 10105, - "Kind": 3 - }, - { - "EndIndex": 10141, - "Kind": 3 - }, - { - "EndIndex": 10182, - "Kind": 3 - }, - { - "EndIndex": 10204, - "Kind": 3 - }, - { - "EndIndex": 10210, - "Kind": 3 - }, - { - "EndIndex": 10242, - "Kind": 3 - }, - { - "EndIndex": 10272, - "Kind": 3 - }, - { - "EndIndex": 10294, - "Kind": 3 - }, - { - "EndIndex": 10300, - "Kind": 3 - }, - { - "EndIndex": 10332, - "Kind": 3 - }, - { - "EndIndex": 10362, - "Kind": 3 - }, - { - "EndIndex": 10384, - "Kind": 3 - }, - { - "EndIndex": 10390, - "Kind": 3 - }, - { - "EndIndex": 10425, - "Kind": 3 - }, - { - "EndIndex": 10464, - "Kind": 3 - }, - { - "EndIndex": 10487, - "Kind": 3 - }, - { - "EndIndex": 10493, - "Kind": 3 - }, - { - "EndIndex": 10518, - "Kind": 3 - }, - { - "EndIndex": 10548, - "Kind": 3 - }, - { - "EndIndex": 10567, - "Kind": 3 - }, - { - "EndIndex": 10573, - "Kind": 3 - }, - { - "EndIndex": 10610, - "Kind": 3 - }, - { - "EndIndex": 10641, - "Kind": 3 - }, - { - "EndIndex": 10663, - "Kind": 3 - }, - { - "EndIndex": 10669, - "Kind": 3 - }, - { - "EndIndex": 10704, - "Kind": 3 - }, - { - "EndIndex": 10735, - "Kind": 3 - }, - { - "EndIndex": 10757, - "Kind": 3 - }, - { - "EndIndex": 10763, - "Kind": 3 - }, - { - "EndIndex": 10795, - "Kind": 3 - }, - { - "EndIndex": 10825, - "Kind": 3 - }, - { - "EndIndex": 10847, - "Kind": 3 - }, - { - "EndIndex": 10853, - "Kind": 3 - }, - { - "EndIndex": 10885, - "Kind": 3 - }, - { - "EndIndex": 10915, - "Kind": 3 - }, - { - "EndIndex": 10937, - "Kind": 3 - }, - { - "EndIndex": 10943, - "Kind": 3 - }, - { - "EndIndex": 10974, - "Kind": 3 - }, - { - "EndIndex": 11004, - "Kind": 3 - }, - { - "EndIndex": 11026, - "Kind": 3 - }, - { - "EndIndex": 11032, - "Kind": 3 - }, - { - "EndIndex": 11069, - "Kind": 3 - }, - { - "EndIndex": 11177, - "Kind": 3 - }, - { - "EndIndex": 11199, - "Kind": 3 - }, - { - "EndIndex": 11205, - "Kind": 3 - }, - { - "EndIndex": 11242, - "Kind": 3 - }, - { - "EndIndex": 11283, - "Kind": 3 - }, - { - "EndIndex": 11305, - "Kind": 3 - }, - { - "EndIndex": 11311, - "Kind": 3 - }, - { - "EndIndex": 11346, - "Kind": 3 - }, - { - "EndIndex": 11377, - "Kind": 3 - }, - { - "EndIndex": 11399, - "Kind": 3 - }, - { - "EndIndex": 11405, - "Kind": 3 - }, - { - "EndIndex": 11439, - "Kind": 3 - }, - { - "EndIndex": 11470, - "Kind": 3 - }, - { - "EndIndex": 11492, - "Kind": 3 - }, - { - "EndIndex": 11498, - "Kind": 3 - }, - { - "EndIndex": 11530, - "Kind": 3 - }, - { - "EndIndex": 11560, - "Kind": 3 - }, - { - "EndIndex": 11582, - "Kind": 3 - }, - { - "EndIndex": 11588, - "Kind": 3 - }, - { - "EndIndex": 11624, - "Kind": 3 - }, - { - "EndIndex": 11654, - "Kind": 3 - }, - { - "EndIndex": 11676, - "Kind": 3 - }, - { - "EndIndex": 11682, - "Kind": 3 - }, - { - "EndIndex": 11714, - "Kind": 3 - }, - { - "EndIndex": 11744, - "Kind": 3 - }, - { - "EndIndex": 11766, - "Kind": 3 - }, - { - "EndIndex": 11772, - "Kind": 3 - }, - { - "EndIndex": 11799, - "Kind": 3 - }, - { - "EndIndex": 11844, - "Kind": 3 - }, - { - "EndIndex": 11862, - "Kind": 3 - }, - { - "EndIndex": 11868, - "Kind": 3 - }, - { - "EndIndex": 11892, - "Kind": 3 - }, - { - "EndIndex": 11921, - "Kind": 3 - }, - { - "EndIndex": 11940, - "Kind": 3 - }, - { - "EndIndex": 11946, - "Kind": 3 - }, - { - "EndIndex": 11977, - "Kind": 3 - }, - { - "EndIndex": 12007, - "Kind": 3 - }, - { - "EndIndex": 12029, - "Kind": 3 - }, - { - "EndIndex": 12035, - "Kind": 3 - }, - { - "EndIndex": 12053, - "Kind": 3 - }, - { - "EndIndex": 12095, - "Kind": 3 - }, - { - "EndIndex": 12421, - "Kind": 3 - }, - { - "EndIndex": 12443, - "Kind": 3 - }, - { - "EndIndex": 12449, - "Kind": 3 - }, - { - "EndIndex": 12484, - "Kind": 3 - }, - { - "EndIndex": 12514, - "Kind": 3 - }, - { - "EndIndex": 12542, - "Kind": 3 - }, - { - "EndIndex": 12548, - "Kind": 3 - }, - { - "EndIndex": 12574, - "Kind": 3 - }, - { - "EndIndex": 12624, - "Kind": 3 - }, - { - "EndIndex": 12646, - "Kind": 3 - }, - { - "EndIndex": 12652, - "Kind": 3 - }, - { - "EndIndex": 12683, - "Kind": 3 - }, - { - "EndIndex": 12713, - "Kind": 3 - }, - { - "EndIndex": 12735, - "Kind": 3 - }, - { - "EndIndex": 12741, - "Kind": 3 - }, - { - "EndIndex": 12768, - "Kind": 3 - }, - { - "EndIndex": 12886, - "Kind": 3 - }, - { - "EndIndex": 12904, - "Kind": 3 - }, - { - "EndIndex": 12910, - "Kind": 3 - }, - { - "EndIndex": 12936, - "Kind": 3 - }, - { - "EndIndex": 12995, - "Kind": 3 - }, - { - "EndIndex": 13025, - "Kind": 3 - }, - { - "EndIndex": 13031, - "Kind": 3 - }, - { - "EndIndex": 13046, - "Kind": 3 - }, - { - "EndIndex": 13074, - "Kind": 3 - }, - { - "EndIndex": 13138, - "Kind": 3 - }, - { - "EndIndex": 13152, - "Kind": 3 - }, - { - "EndIndex": 13158, - "Kind": 3 - }, - { - "EndIndex": 13176, - "Kind": 3 - }, - { - "EndIndex": 13226, - "Kind": 3 - }, - { - "EndIndex": 13990, - "Kind": 3 - }, - { - "EndIndex": 14008, - "Kind": 3 - }, - { - "EndIndex": 14014, - "Kind": 3 - }, - { - "EndIndex": 14029, - "Kind": 3 - }, - { - "EndIndex": 14050, - "Kind": 3 - }, - { - "EndIndex": 14100, - "Kind": 3 - }, - { - "EndIndex": 14114, - "Kind": 3 - }, - { - "EndIndex": 14120, - "Kind": 3 - }, - { - "EndIndex": 14135, - "Kind": 3 - }, - { - "EndIndex": 14161, - "Kind": 3 - }, - { - "EndIndex": 14223, - "Kind": 3 - }, - { - "EndIndex": 14237, - "Kind": 3 - }, - { - "EndIndex": 14243, - "Kind": 3 - }, - { - "EndIndex": 14258, - "Kind": 3 - }, - { - "EndIndex": 14279, - "Kind": 3 - }, - { - "EndIndex": 14324, - "Kind": 3 - }, - { - "EndIndex": 14338, - "Kind": 3 - }, - { - "EndIndex": 14344, - "Kind": 3 - }, - { - "EndIndex": 14388, - "Kind": 3 - }, - { - "EndIndex": 15131, - "Kind": 3 - }, - { - "EndIndex": 15151, - "Kind": 3 - }, - { - "EndIndex": 15157, - "Kind": 3 - }, - { - "EndIndex": 15159, - "Kind": 3 - }, - { - "EndIndex": 15174, - "Kind": 3 - }, - { - "EndIndex": 15192, - "Kind": 3 - }, - { - "EndIndex": 15426, - "Kind": 3 - }, - { - "EndIndex": 15457, - "Kind": 3 - }, - { - "EndIndex": 15487, - "Kind": 3 - }, - { - "EndIndex": 15510, - "Kind": 3 - }, - { - "EndIndex": 15516, - "Kind": 3 - }, - { - "EndIndex": 15538, - "Kind": 3 - }, - { - "EndIndex": 15566, - "Kind": 3 - }, - { - "EndIndex": 15804, - "Kind": 3 - }, - { - "EndIndex": 15818, - "Kind": 3 - }, - { - "EndIndex": 15824, - "Kind": 3 - }, - { - "EndIndex": 15842, - "Kind": 3 - }, - { - "EndIndex": 15875, - "Kind": 3 - }, - { - "EndIndex": 16026, - "Kind": 3 - }, - { - "EndIndex": 16047, - "Kind": 3 - }, - { - "EndIndex": 16053, - "Kind": 3 - }, - { - "EndIndex": 16083, - "Kind": 3 - }, - { - "EndIndex": 16113, - "Kind": 3 - }, - { - "EndIndex": 16136, - "Kind": 3 - }, - { - "EndIndex": 16142, - "Kind": 3 - }, - { - "EndIndex": 16174, - "Kind": 3 - }, - { - "EndIndex": 16204, - "Kind": 3 - }, - { - "EndIndex": 16227, - "Kind": 3 - }, - { - "EndIndex": 16233, - "Kind": 3 - }, - { - "EndIndex": 16258, - "Kind": 3 - }, - { - "EndIndex": 16288, - "Kind": 3 - }, - { - "EndIndex": 16307, - "Kind": 3 - }, - { - "EndIndex": 16313, - "Kind": 3 - }, - { - "EndIndex": 16344, - "Kind": 3 - }, - { - "EndIndex": 16374, - "Kind": 3 - }, - { - "EndIndex": 16397, - "Kind": 3 - }, - { - "EndIndex": 16403, - "Kind": 3 - }, - { - "EndIndex": 16435, - "Kind": 3 - }, - { - "EndIndex": 16465, - "Kind": 3 - }, - { - "EndIndex": 16488, - "Kind": 3 - }, - { - "EndIndex": 16494, - "Kind": 3 - }, - { - "EndIndex": 16518, - "Kind": 3 - }, - { - "EndIndex": 16547, - "Kind": 3 - }, - { - "EndIndex": 16566, - "Kind": 3 - }, - { - "EndIndex": 16572, - "Kind": 3 - }, - { - "EndIndex": 16590, - "Kind": 3 - }, - { - "EndIndex": 16632, - "Kind": 3 - }, - { - "EndIndex": 16958, - "Kind": 3 - }, - { - "EndIndex": 16980, - "Kind": 3 - }, - { - "EndIndex": 16986, - "Kind": 3 - }, - { - "EndIndex": 17017, - "Kind": 3 - }, - { - "EndIndex": 17047, - "Kind": 3 - }, - { - "EndIndex": 17070, - "Kind": 3 - }, - { - "EndIndex": 17076, - "Kind": 3 - }, - { - "EndIndex": 17094, - "Kind": 3 - }, - { - "EndIndex": 17144, - "Kind": 3 - }, - { - "EndIndex": 17908, - "Kind": 3 - }, - { - "EndIndex": 17930, - "Kind": 3 - }, - { - "EndIndex": 17936, - "Kind": 3 - }, - { - "EndIndex": 17938, - "Kind": 3 - }, - { - "EndIndex": 17955, - "Kind": 3 - }, - { - "EndIndex": 17975, - "Kind": 3 - }, - { - "EndIndex": 17997, - "Kind": 3 - }, - { - "EndIndex": 18072, - "Kind": 3 - }, - { - "EndIndex": 18096, - "Kind": 3 - }, - { - "EndIndex": 18117, - "Kind": 3 - }, - { - "EndIndex": 18141, - "Kind": 3 - }, - { - "EndIndex": 18147, - "Kind": 3 - }, - { - "EndIndex": 18178, - "Kind": 3 - }, - { - "EndIndex": 18208, - "Kind": 3 - }, - { - "EndIndex": 18232, - "Kind": 3 - }, - { - "EndIndex": 18238, - "Kind": 3 - }, - { - "EndIndex": 18263, - "Kind": 3 - }, - { - "EndIndex": 18284, - "Kind": 3 - }, - { - "EndIndex": 18306, - "Kind": 3 - }, - { - "EndIndex": 18312, - "Kind": 3 - }, - { - "EndIndex": 18335, - "Kind": 3 - }, - { - "EndIndex": 18369, - "Kind": 3 - }, - { - "EndIndex": 18408, - "Kind": 3 - }, - { - "EndIndex": 18431, - "Kind": 3 - }, - { - "EndIndex": 18437, - "Kind": 3 - }, - { - "EndIndex": 18467, - "Kind": 3 - }, - { - "EndIndex": 18498, - "Kind": 3 - }, - { - "EndIndex": 18520, - "Kind": 3 - }, - { - "EndIndex": 18526, - "Kind": 3 - }, - { - "EndIndex": 18552, - "Kind": 3 - }, - { - "EndIndex": 18575, - "Kind": 3 - }, - { - "EndIndex": 18595, - "Kind": 3 - }, - { - "EndIndex": 18601, - "Kind": 3 - }, - { - "EndIndex": 18637, - "Kind": 3 - }, - { - "EndIndex": 18668, - "Kind": 3 - }, - { - "EndIndex": 18686, - "Kind": 3 - }, - { - "EndIndex": 18692, - "Kind": 3 - }, - { - "EndIndex": 18732, - "Kind": 3 - }, - { - "EndIndex": 18787, - "Kind": 3 - }, - { - "EndIndex": 18806, - "Kind": 3 - }, - { - "EndIndex": 18812, - "Kind": 3 - }, - { - "EndIndex": 18842, - "Kind": 3 - }, - { - "EndIndex": 18873, - "Kind": 3 - }, - { - "EndIndex": 18895, - "Kind": 3 - }, - { - "EndIndex": 18901, - "Kind": 3 - }, - { - "EndIndex": 18940, - "Kind": 3 - }, - { - "EndIndex": 18979, - "Kind": 3 - }, - { - "EndIndex": 18993, - "Kind": 3 - }, - { - "EndIndex": 18999, - "Kind": 3 - }, - { - "EndIndex": 19017, - "Kind": 3 - }, - { - "EndIndex": 19061, - "Kind": 3 - }, - { - "EndIndex": 19404, - "Kind": 3 - }, - { - "EndIndex": 19423, - "Kind": 3 - }, - { - "EndIndex": 19429, - "Kind": 3 - }, - { - "EndIndex": 19460, - "Kind": 3 - }, - { - "EndIndex": 19479, - "Kind": 3 - }, - { - "EndIndex": 19485, - "Kind": 3 - }, - { - "EndIndex": 19515, - "Kind": 3 - }, - { - "EndIndex": 19545, - "Kind": 3 - }, - { - "EndIndex": 19567, - "Kind": 3 - }, - { - "EndIndex": 19573, - "Kind": 3 - }, - { - "EndIndex": 19598, - "Kind": 3 - }, - { - "EndIndex": 19628, - "Kind": 3 - }, - { - "EndIndex": 19646, - "Kind": 3 - }, - { - "EndIndex": 19652, - "Kind": 3 - }, - { - "EndIndex": 19694, - "Kind": 3 - }, - { - "EndIndex": 19773, - "Kind": 3 - }, - { - "EndIndex": 19787, - "Kind": 3 - }, - { - "EndIndex": 19793, - "Kind": 3 - }, - { - "EndIndex": 19811, - "Kind": 3 - }, - { - "EndIndex": 19844, - "Kind": 3 - }, - { - "EndIndex": 19995, - "Kind": 3 - }, - { - "EndIndex": 20016, - "Kind": 3 - }, - { - "EndIndex": 20022, - "Kind": 3 - }, - { - "EndIndex": 20046, - "Kind": 3 - }, - { - "EndIndex": 20067, - "Kind": 3 - }, - { - "EndIndex": 20085, - "Kind": 3 - }, - { - "EndIndex": 20091, - "Kind": 3 - }, - { - "EndIndex": 20121, - "Kind": 3 - }, - { - "EndIndex": 20152, - "Kind": 3 - }, - { - "EndIndex": 20174, - "Kind": 3 - }, - { - "EndIndex": 20180, - "Kind": 3 - }, - { - "EndIndex": 20210, - "Kind": 3 - }, - { - "EndIndex": 20240, - "Kind": 3 - }, - { - "EndIndex": 20262, - "Kind": 3 - }, - { - "EndIndex": 20268, - "Kind": 3 - }, - { - "EndIndex": 20299, - "Kind": 3 - }, - { - "EndIndex": 20329, - "Kind": 3 - }, - { - "EndIndex": 20353, - "Kind": 3 - }, - { - "EndIndex": 20359, - "Kind": 3 - }, - { - "EndIndex": 20390, - "Kind": 3 - }, - { - "EndIndex": 20420, - "Kind": 3 - }, - { - "EndIndex": 20444, - "Kind": 3 - }, - { - "EndIndex": 20450, - "Kind": 3 - }, - { - "EndIndex": 20480, - "Kind": 3 - }, - { - "EndIndex": 20511, - "Kind": 3 - }, - { - "EndIndex": 20533, - "Kind": 3 - }, - { - "EndIndex": 20539, - "Kind": 3 - }, - { - "EndIndex": 20563, - "Kind": 3 - }, - { - "EndIndex": 20580, - "Kind": 3 - }, - { - "EndIndex": 20604, - "Kind": 3 - }, - { - "EndIndex": 20610, - "Kind": 3 - }, - { - "EndIndex": 20634, - "Kind": 3 - }, - { - "EndIndex": 20651, - "Kind": 3 - }, - { - "EndIndex": 20675, - "Kind": 3 - }, - { - "EndIndex": 20681, - "Kind": 3 - }, - { - "EndIndex": 20717, - "Kind": 3 - }, - { - "EndIndex": 20758, - "Kind": 3 - }, - { - "EndIndex": 20782, - "Kind": 3 - }, - { - "EndIndex": 20788, - "Kind": 3 - }, - { - "EndIndex": 20820, - "Kind": 3 - }, - { - "EndIndex": 20850, - "Kind": 3 - }, - { - "EndIndex": 20874, - "Kind": 3 - }, - { - "EndIndex": 20880, - "Kind": 3 - }, - { - "EndIndex": 20915, - "Kind": 3 - }, - { - "EndIndex": 20954, - "Kind": 3 - }, - { - "EndIndex": 20977, - "Kind": 3 - }, - { - "EndIndex": 20983, - "Kind": 3 - }, - { - "EndIndex": 21008, - "Kind": 3 - }, - { - "EndIndex": 21038, - "Kind": 3 - }, - { - "EndIndex": 21057, - "Kind": 3 - }, - { - "EndIndex": 21063, - "Kind": 3 - }, - { - "EndIndex": 21100, - "Kind": 3 - }, - { - "EndIndex": 21131, - "Kind": 3 - }, - { - "EndIndex": 21155, - "Kind": 3 - }, - { - "EndIndex": 21161, - "Kind": 3 - }, - { - "EndIndex": 21193, - "Kind": 3 - }, - { - "EndIndex": 21223, - "Kind": 3 - }, - { - "EndIndex": 21247, - "Kind": 3 - }, - { - "EndIndex": 21253, - "Kind": 3 - }, - { - "EndIndex": 21285, - "Kind": 3 - }, - { - "EndIndex": 21315, - "Kind": 3 - }, - { - "EndIndex": 21339, - "Kind": 3 - }, - { - "EndIndex": 21345, - "Kind": 3 - }, - { - "EndIndex": 21380, - "Kind": 3 - }, - { - "EndIndex": 21521, - "Kind": 3 - }, - { - "EndIndex": 21545, - "Kind": 3 - }, - { - "EndIndex": 21551, - "Kind": 3 - }, - { - "EndIndex": 21588, - "Kind": 3 - }, - { - "EndIndex": 21629, - "Kind": 3 - }, - { - "EndIndex": 21653, - "Kind": 3 - }, - { - "EndIndex": 21659, - "Kind": 3 - }, - { - "EndIndex": 21691, - "Kind": 3 - }, - { - "EndIndex": 21721, - "Kind": 3 - }, - { - "EndIndex": 21745, - "Kind": 3 - }, - { - "EndIndex": 21751, - "Kind": 3 - }, - { - "EndIndex": 21787, - "Kind": 3 - }, - { - "EndIndex": 21817, - "Kind": 3 - }, - { - "EndIndex": 21841, - "Kind": 3 - }, - { - "EndIndex": 21847, - "Kind": 3 - }, - { - "EndIndex": 21865, - "Kind": 3 - }, - { - "EndIndex": 21915, - "Kind": 3 - }, - { - "EndIndex": 22405, - "Kind": 3 - }, - { - "EndIndex": 22419, - "Kind": 3 - }, - { - "EndIndex": 22425, - "Kind": 3 - }, - { - "EndIndex": 22449, - "Kind": 3 - }, - { - "EndIndex": 22478, - "Kind": 3 - }, - { - "EndIndex": 22497, - "Kind": 3 - }, - { - "EndIndex": 22503, - "Kind": 3 - }, - { - "EndIndex": 22534, - "Kind": 3 - }, - { - "EndIndex": 22564, - "Kind": 3 - }, - { - "EndIndex": 22588, - "Kind": 3 - }, - { - "EndIndex": 22594, - "Kind": 3 - }, - { - "EndIndex": 22612, - "Kind": 3 - }, - { - "EndIndex": 22654, - "Kind": 3 - }, - { - "EndIndex": 22980, - "Kind": 3 - }, - { - "EndIndex": 23002, - "Kind": 3 - }, - { - "EndIndex": 23008, - "Kind": 3 - }, - { - "EndIndex": 23043, - "Kind": 3 - }, - { - "EndIndex": 23073, - "Kind": 3 - }, - { - "EndIndex": 23101, - "Kind": 3 - }, - { - "EndIndex": 23107, - "Kind": 3 - }, - { - "EndIndex": 23133, - "Kind": 3 - }, - { - "EndIndex": 23194, - "Kind": 3 - }, - { - "EndIndex": 23218, - "Kind": 3 - }, - { - "EndIndex": 23224, - "Kind": 3 - }, - { - "EndIndex": 23257, - "Kind": 3 - }, - { - "EndIndex": 23588, - "Kind": 3 - }, - { - "EndIndex": 23611, - "Kind": 3 - }, - { - "EndIndex": 23617, - "Kind": 3 - }, - { - "EndIndex": 23643, - "Kind": 3 - }, - { - "EndIndex": 23703, - "Kind": 3 - }, - { - "EndIndex": 23733, - "Kind": 3 - }, - { - "EndIndex": 23739, - "Kind": 3 - }, - { - "EndIndex": 23757, - "Kind": 3 - }, - { - "EndIndex": 23794, - "Kind": 3 - }, - { - "EndIndex": 23954, - "Kind": 3 - }, - { - "EndIndex": 23974, - "Kind": 3 - }, - { - "EndIndex": 23980, - "Kind": 3 - }, - { - "EndIndex": 24000, - "Kind": 3 - }, - { - "EndIndex": 24163, - "Kind": 3 - }, - { - "EndIndex": 24182, - "Kind": 3 - }, - { - "EndIndex": 24188, - "Kind": 3 - }, - { - "EndIndex": 24203, - "Kind": 3 - }, - { - "EndIndex": 24224, - "Kind": 3 - }, - { - "EndIndex": 24274, - "Kind": 3 - }, - { - "EndIndex": 24288, - "Kind": 3 - }, - { - "EndIndex": 24294, - "Kind": 3 - }, - { - "EndIndex": 24321, - "Kind": 3 - }, - { - "EndIndex": 24372, - "Kind": 3 - }, - { - "EndIndex": 24394, - "Kind": 3 - }, - { - "EndIndex": 24400, - "Kind": 3 - }, - { - "EndIndex": 24415, - "Kind": 3 - }, - { - "EndIndex": 24436, - "Kind": 3 - }, - { - "EndIndex": 24481, - "Kind": 3 - }, - { - "EndIndex": 24495, - "Kind": 3 - }, - { - "EndIndex": 24501, - "Kind": 3 - }, - { - "EndIndex": 24503, - "Kind": 3 - }, - { - "EndIndex": 24522, - "Kind": 3 - }, - { - "EndIndex": 24546, - "Kind": 3 - }, - { - "EndIndex": 24694, - "Kind": 3 - }, - { - "EndIndex": 24718, - "Kind": 3 - }, - { - "EndIndex": 24739, - "Kind": 3 - }, - { - "EndIndex": 24765, - "Kind": 3 - }, - { - "EndIndex": 24771, - "Kind": 3 - }, - { - "EndIndex": 24802, - "Kind": 3 - }, - { - "EndIndex": 24832, - "Kind": 3 - }, - { - "EndIndex": 24858, - "Kind": 3 - }, - { - "EndIndex": 24864, - "Kind": 3 - }, - { - "EndIndex": 24889, - "Kind": 3 - }, - { - "EndIndex": 24910, - "Kind": 3 - }, - { - "EndIndex": 24932, - "Kind": 3 - }, - { - "EndIndex": 24938, - "Kind": 3 - }, - { - "EndIndex": 24963, - "Kind": 3 - }, - { - "EndIndex": 24997, - "Kind": 3 - }, - { - "EndIndex": 25036, - "Kind": 3 - }, - { - "EndIndex": 25059, - "Kind": 3 - }, - { - "EndIndex": 25065, - "Kind": 3 - }, - { - "EndIndex": 25095, - "Kind": 3 - }, - { - "EndIndex": 25126, - "Kind": 3 - }, - { - "EndIndex": 25148, - "Kind": 3 - }, - { - "EndIndex": 25154, - "Kind": 3 - }, - { - "EndIndex": 25180, - "Kind": 3 - }, - { - "EndIndex": 25203, - "Kind": 3 - }, - { - "EndIndex": 25223, - "Kind": 3 - }, - { - "EndIndex": 25229, - "Kind": 3 - }, - { - "EndIndex": 25265, - "Kind": 3 - }, - { - "EndIndex": 25296, - "Kind": 3 - }, - { - "EndIndex": 25314, - "Kind": 3 - }, - { - "EndIndex": 25320, - "Kind": 3 - }, - { - "EndIndex": 25360, - "Kind": 3 - }, - { - "EndIndex": 25448, - "Kind": 3 - }, - { - "EndIndex": 25467, - "Kind": 3 - }, - { - "EndIndex": 25473, - "Kind": 3 - }, - { - "EndIndex": 25503, - "Kind": 3 - }, - { - "EndIndex": 25534, - "Kind": 3 - }, - { - "EndIndex": 25556, - "Kind": 3 - }, - { - "EndIndex": 25562, - "Kind": 3 - }, - { - "EndIndex": 25601, - "Kind": 3 - }, - { - "EndIndex": 25640, - "Kind": 3 - }, - { - "EndIndex": 25654, - "Kind": 3 - }, - { - "EndIndex": 25660, - "Kind": 3 - }, - { - "EndIndex": 25691, - "Kind": 3 - }, - { - "EndIndex": 25710, - "Kind": 3 - }, - { - "EndIndex": 25716, - "Kind": 3 - }, - { - "EndIndex": 25746, - "Kind": 3 - }, - { - "EndIndex": 25776, - "Kind": 3 - }, - { - "EndIndex": 25798, - "Kind": 3 - }, - { - "EndIndex": 25804, - "Kind": 3 - }, - { - "EndIndex": 25829, - "Kind": 3 - }, - { - "EndIndex": 25859, - "Kind": 3 - }, - { - "EndIndex": 25877, - "Kind": 3 - }, - { - "EndIndex": 25883, - "Kind": 3 - }, - { - "EndIndex": 25925, - "Kind": 3 - }, - { - "EndIndex": 26077, - "Kind": 3 - }, - { - "EndIndex": 26091, - "Kind": 3 - }, - { - "EndIndex": 26097, - "Kind": 3 - }, - { - "EndIndex": 26115, - "Kind": 3 - }, - { - "EndIndex": 26148, - "Kind": 3 - }, - { - "EndIndex": 26299, - "Kind": 3 - }, - { - "EndIndex": 26320, - "Kind": 3 - }, - { - "EndIndex": 26326, - "Kind": 3 - }, - { - "EndIndex": 26350, - "Kind": 3 - }, - { - "EndIndex": 26371, - "Kind": 3 - }, - { - "EndIndex": 26389, - "Kind": 3 - }, - { - "EndIndex": 26395, - "Kind": 3 - }, - { - "EndIndex": 26425, - "Kind": 3 - }, - { - "EndIndex": 26456, - "Kind": 3 - }, - { - "EndIndex": 26478, - "Kind": 3 - }, - { - "EndIndex": 26484, - "Kind": 3 - }, - { - "EndIndex": 26514, - "Kind": 3 - }, - { - "EndIndex": 26544, - "Kind": 3 - }, - { - "EndIndex": 26566, - "Kind": 3 - }, - { - "EndIndex": 26572, - "Kind": 3 - }, - { - "EndIndex": 26603, - "Kind": 3 - }, - { - "EndIndex": 26633, - "Kind": 3 - }, - { - "EndIndex": 26659, - "Kind": 3 - }, - { - "EndIndex": 26665, - "Kind": 3 - }, - { - "EndIndex": 26696, - "Kind": 3 - }, - { - "EndIndex": 26726, - "Kind": 3 - }, - { - "EndIndex": 26752, - "Kind": 3 - }, - { - "EndIndex": 26758, - "Kind": 3 - }, - { - "EndIndex": 26788, - "Kind": 3 - }, - { - "EndIndex": 26819, - "Kind": 3 - }, - { - "EndIndex": 26841, - "Kind": 3 - }, - { - "EndIndex": 26847, - "Kind": 3 - }, - { - "EndIndex": 26871, - "Kind": 3 - }, - { - "EndIndex": 26888, - "Kind": 3 - }, - { - "EndIndex": 26914, - "Kind": 3 - }, - { - "EndIndex": 26920, - "Kind": 3 - }, - { - "EndIndex": 26944, - "Kind": 3 - }, - { - "EndIndex": 26961, - "Kind": 3 - }, - { - "EndIndex": 26987, - "Kind": 3 - }, - { - "EndIndex": 26993, - "Kind": 3 - }, - { - "EndIndex": 27029, - "Kind": 3 - }, - { - "EndIndex": 27070, - "Kind": 3 - }, - { - "EndIndex": 27096, - "Kind": 3 - }, - { - "EndIndex": 27102, - "Kind": 3 - }, - { - "EndIndex": 27134, - "Kind": 3 - }, - { - "EndIndex": 27164, - "Kind": 3 - }, - { - "EndIndex": 27190, - "Kind": 3 - }, - { - "EndIndex": 27196, - "Kind": 3 - }, - { - "EndIndex": 27231, - "Kind": 3 - }, - { - "EndIndex": 27270, - "Kind": 3 - }, - { - "EndIndex": 27293, - "Kind": 3 - }, - { - "EndIndex": 27299, - "Kind": 3 - }, - { - "EndIndex": 27324, - "Kind": 3 - }, - { - "EndIndex": 27354, - "Kind": 3 - }, - { - "EndIndex": 27373, - "Kind": 3 - }, - { - "EndIndex": 27379, - "Kind": 3 - }, - { - "EndIndex": 27416, - "Kind": 3 - }, - { - "EndIndex": 27447, - "Kind": 3 - }, - { - "EndIndex": 27473, - "Kind": 3 - }, - { - "EndIndex": 27479, - "Kind": 3 - }, - { - "EndIndex": 27511, - "Kind": 3 - }, - { - "EndIndex": 27541, - "Kind": 3 - }, - { - "EndIndex": 27567, - "Kind": 3 - }, - { - "EndIndex": 27573, - "Kind": 3 - }, - { - "EndIndex": 27605, - "Kind": 3 - }, - { - "EndIndex": 27635, - "Kind": 3 - }, - { - "EndIndex": 27661, - "Kind": 3 - }, - { - "EndIndex": 27667, - "Kind": 3 - }, - { - "EndIndex": 27704, - "Kind": 3 - }, - { - "EndIndex": 27745, - "Kind": 3 - }, - { - "EndIndex": 27771, - "Kind": 3 - }, - { - "EndIndex": 27777, - "Kind": 3 - }, - { - "EndIndex": 27809, - "Kind": 3 - }, - { - "EndIndex": 27839, - "Kind": 3 - }, - { - "EndIndex": 27865, - "Kind": 3 - }, - { - "EndIndex": 27871, - "Kind": 3 - }, - { - "EndIndex": 27907, - "Kind": 3 - }, - { - "EndIndex": 27937, - "Kind": 3 - }, - { - "EndIndex": 27963, - "Kind": 3 - }, - { - "EndIndex": 27969, - "Kind": 3 - }, - { - "EndIndex": 27993, - "Kind": 3 - }, - { - "EndIndex": 28022, - "Kind": 3 - }, - { - "EndIndex": 28041, - "Kind": 3 - }, - { - "EndIndex": 28047, - "Kind": 3 - }, - { - "EndIndex": 28078, - "Kind": 3 - }, - { - "EndIndex": 28108, - "Kind": 3 - }, - { - "EndIndex": 28134, - "Kind": 3 - }, - { - "EndIndex": 28140, - "Kind": 3 - }, - { - "EndIndex": 28158, - "Kind": 3 - }, - { - "EndIndex": 28200, - "Kind": 3 - }, - { - "EndIndex": 28526, - "Kind": 3 - }, - { - "EndIndex": 28548, - "Kind": 3 - }, - { - "EndIndex": 28554, - "Kind": 3 - }, - { - "EndIndex": 28589, - "Kind": 3 - }, - { - "EndIndex": 28619, - "Kind": 3 - }, - { - "EndIndex": 28647, - "Kind": 3 - }, - { - "EndIndex": 28653, - "Kind": 3 - }, - { - "EndIndex": 28679, - "Kind": 3 - }, - { - "EndIndex": 28798, - "Kind": 3 - }, - { - "EndIndex": 28828, - "Kind": 3 - }, - { - "EndIndex": 28834, - "Kind": 3 - }, - { - "EndIndex": 28849, - "Kind": 3 - }, - { - "EndIndex": 28870, - "Kind": 3 - }, - { - "EndIndex": 28920, - "Kind": 3 - }, - { - "EndIndex": 28934, - "Kind": 3 - }, - { - "EndIndex": 28940, - "Kind": 3 - }, - { - "EndIndex": 28955, - "Kind": 3 - }, - { - "EndIndex": 28976, - "Kind": 3 - }, - { - "EndIndex": 29021, - "Kind": 3 - }, - { - "EndIndex": 29035, - "Kind": 3 - }, - { - "EndIndex": 29041, - "Kind": 3 - }, - { - "EndIndex": 29043, - "Kind": 3 - }, - { - "EndIndex": 29066, - "Kind": 3 - }, - { - "EndIndex": 29088, - "Kind": 3 - }, - { - "EndIndex": 29334, - "Kind": 3 - }, - { - "EndIndex": 29365, - "Kind": 3 - }, - { - "EndIndex": 29395, - "Kind": 3 - }, - { - "EndIndex": 29419, - "Kind": 3 - }, - { - "EndIndex": 29425, - "Kind": 3 - }, - { - "EndIndex": 29448, - "Kind": 3 - }, - { - "EndIndex": 29482, - "Kind": 3 - }, - { - "EndIndex": 29513, - "Kind": 3 - }, - { - "EndIndex": 29535, - "Kind": 3 - }, - { - "EndIndex": 29541, - "Kind": 3 - }, - { - "EndIndex": 29571, - "Kind": 3 - }, - { - "EndIndex": 29602, - "Kind": 3 - }, - { - "EndIndex": 29624, - "Kind": 3 - }, - { - "EndIndex": 29630, - "Kind": 3 - }, - { - "EndIndex": 29660, - "Kind": 3 - }, - { - "EndIndex": 29691, - "Kind": 3 - }, - { - "EndIndex": 29713, - "Kind": 3 - }, - { - "EndIndex": 29719, - "Kind": 3 - }, - { - "EndIndex": 29758, - "Kind": 3 - }, - { - "EndIndex": 29797, - "Kind": 3 - }, - { - "EndIndex": 29811, - "Kind": 3 - }, - { - "EndIndex": 29817, - "Kind": 3 - }, - { - "EndIndex": 29850, - "Kind": 3 - }, - { - "EndIndex": 29879, - "Kind": 3 - }, - { - "EndIndex": 29893, - "Kind": 3 - }, - { - "EndIndex": 29899, - "Kind": 3 - }, - { - "EndIndex": 29930, - "Kind": 3 - }, - { - "EndIndex": 29949, - "Kind": 3 - }, - { - "EndIndex": 29955, - "Kind": 3 - }, - { - "EndIndex": 29985, - "Kind": 3 - }, - { - "EndIndex": 30015, - "Kind": 3 - }, - { - "EndIndex": 30037, - "Kind": 3 - }, - { - "EndIndex": 30043, - "Kind": 3 - }, - { - "EndIndex": 30068, - "Kind": 3 - }, - { - "EndIndex": 30098, - "Kind": 3 - }, - { - "EndIndex": 30116, - "Kind": 3 - }, - { - "EndIndex": 30122, - "Kind": 3 - }, - { - "EndIndex": 30164, - "Kind": 3 - }, - { - "EndIndex": 30414, - "Kind": 3 - }, - { - "EndIndex": 30428, - "Kind": 3 - }, - { - "EndIndex": 30434, - "Kind": 3 - }, - { - "EndIndex": 30452, - "Kind": 3 - }, - { - "EndIndex": 30485, - "Kind": 3 - }, - { - "EndIndex": 30636, - "Kind": 3 - }, - { - "EndIndex": 30657, - "Kind": 3 - }, - { - "EndIndex": 30663, - "Kind": 3 - }, - { - "EndIndex": 30688, - "Kind": 3 - }, - { - "EndIndex": 30721, - "Kind": 3 - }, - { - "EndIndex": 30757, - "Kind": 3 - }, - { - "EndIndex": 30763, - "Kind": 3 - }, - { - "EndIndex": 30793, - "Kind": 3 - }, - { - "EndIndex": 30824, - "Kind": 3 - }, - { - "EndIndex": 30846, - "Kind": 3 - }, - { - "EndIndex": 30852, - "Kind": 3 - }, - { - "EndIndex": 30876, - "Kind": 3 - }, - { - "EndIndex": 30905, - "Kind": 3 - }, - { - "EndIndex": 30923, - "Kind": 3 - }, - { - "EndIndex": 30929, - "Kind": 3 - }, - { - "EndIndex": 30959, - "Kind": 3 - }, - { - "EndIndex": 30989, - "Kind": 3 - }, - { - "EndIndex": 31011, - "Kind": 3 - }, - { - "EndIndex": 31017, - "Kind": 3 - }, - { - "EndIndex": 31048, - "Kind": 3 - }, - { - "EndIndex": 31078, - "Kind": 3 - }, - { - "EndIndex": 31102, - "Kind": 3 - }, - { - "EndIndex": 31108, - "Kind": 3 - }, - { - "EndIndex": 31138, - "Kind": 3 - }, - { - "EndIndex": 31169, - "Kind": 3 - }, - { - "EndIndex": 31191, - "Kind": 3 - }, - { - "EndIndex": 31197, - "Kind": 3 - }, - { - "EndIndex": 31222, - "Kind": 3 - }, - { - "EndIndex": 31252, - "Kind": 3 - }, - { - "EndIndex": 31271, - "Kind": 3 - }, - { - "EndIndex": 31277, - "Kind": 3 - }, - { - "EndIndex": 31309, - "Kind": 3 - }, - { - "EndIndex": 31339, - "Kind": 3 - }, - { - "EndIndex": 31363, - "Kind": 3 - }, - { - "EndIndex": 31369, - "Kind": 3 - }, - { - "EndIndex": 31387, - "Kind": 3 - }, - { - "EndIndex": 31429, - "Kind": 3 - }, - { - "EndIndex": 31755, - "Kind": 3 - }, - { - "EndIndex": 31777, - "Kind": 3 - }, - { - "EndIndex": 31783, - "Kind": 3 - }, - { - "EndIndex": 31812, - "Kind": 3 - }, - { - "EndIndex": 31862, - "Kind": 3 - }, - { - "EndIndex": 31880, - "Kind": 3 - }, - { - "EndIndex": 31886, - "Kind": 3 - }, - { - "EndIndex": 31928, - "Kind": 3 - }, - { - "EndIndex": 32018, - "Kind": 3 - }, - { - "EndIndex": 32036, - "Kind": 3 - }, - { - "EndIndex": 32042, - "Kind": 3 - }, - { - "EndIndex": 32044, - "Kind": 3 - }, - { - "EndIndex": 32063, - "Kind": 3 - }, - { - "EndIndex": 32084, - "Kind": 3 - }, - { - "EndIndex": 32236, - "Kind": 3 - }, - { - "EndIndex": 32267, - "Kind": 3 - }, - { - "EndIndex": 32297, - "Kind": 3 - }, - { - "EndIndex": 32320, - "Kind": 3 - }, - { - "EndIndex": 32326, - "Kind": 3 - }, - { - "EndIndex": 32348, - "Kind": 3 - }, - { - "EndIndex": 32382, - "Kind": 3 - }, - { - "EndIndex": 32413, - "Kind": 3 - }, - { - "EndIndex": 32435, - "Kind": 3 - }, - { - "EndIndex": 32441, - "Kind": 3 - }, - { - "EndIndex": 32474, - "Kind": 3 - }, - { - "EndIndex": 32503, - "Kind": 3 - }, - { - "EndIndex": 32524, - "Kind": 3 - }, - { - "EndIndex": 32530, - "Kind": 3 - }, - { - "EndIndex": 32560, - "Kind": 3 - }, - { - "EndIndex": 32591, - "Kind": 3 - }, - { - "EndIndex": 32613, - "Kind": 3 - }, - { - "EndIndex": 32619, - "Kind": 3 - }, - { - "EndIndex": 32649, - "Kind": 3 - }, - { - "EndIndex": 32680, - "Kind": 3 - }, - { - "EndIndex": 32702, - "Kind": 3 - }, - { - "EndIndex": 32708, - "Kind": 3 - }, - { - "EndIndex": 32747, - "Kind": 3 - }, - { - "EndIndex": 32786, - "Kind": 3 - }, - { - "EndIndex": 32800, - "Kind": 3 - }, - { - "EndIndex": 32806, - "Kind": 3 - }, - { - "EndIndex": 32841, - "Kind": 3 - }, - { - "EndIndex": 32879, - "Kind": 3 - }, - { - "EndIndex": 32893, - "Kind": 3 - }, - { - "EndIndex": 32899, - "Kind": 3 - }, - { - "EndIndex": 32929, - "Kind": 3 - }, - { - "EndIndex": 32959, - "Kind": 3 - }, - { - "EndIndex": 32981, - "Kind": 3 - }, - { - "EndIndex": 32987, - "Kind": 3 - }, - { - "EndIndex": 33008, - "Kind": 3 - }, - { - "EndIndex": 33040, - "Kind": 3 - }, - { - "EndIndex": 33074, - "Kind": 3 - }, - { - "EndIndex": 33095, - "Kind": 3 - }, - { - "EndIndex": 33101, - "Kind": 3 - }, - { - "EndIndex": 33133, - "Kind": 3 - }, - { - "EndIndex": 33167, - "Kind": 3 - }, - { - "EndIndex": 33188, - "Kind": 3 - }, - { - "EndIndex": 33194, - "Kind": 3 - }, - { - "EndIndex": 33236, - "Kind": 3 - }, - { - "EndIndex": 33392, - "Kind": 3 - }, - { - "EndIndex": 33406, - "Kind": 3 - }, - { - "EndIndex": 33412, - "Kind": 3 - }, - { - "EndIndex": 33430, - "Kind": 3 - }, - { - "EndIndex": 33463, - "Kind": 3 - }, - { - "EndIndex": 33614, - "Kind": 3 - }, - { - "EndIndex": 33635, - "Kind": 3 - }, - { - "EndIndex": 33641, - "Kind": 3 - }, - { - "EndIndex": 33666, - "Kind": 3 - }, - { - "EndIndex": 33699, - "Kind": 3 - }, - { - "EndIndex": 33734, - "Kind": 3 - }, - { - "EndIndex": 33740, - "Kind": 3 - }, - { - "EndIndex": 33770, - "Kind": 3 - }, - { - "EndIndex": 33801, - "Kind": 3 - }, - { - "EndIndex": 33823, - "Kind": 3 - }, - { - "EndIndex": 33829, - "Kind": 3 - }, - { - "EndIndex": 33853, - "Kind": 3 - }, - { - "EndIndex": 33882, - "Kind": 3 - }, - { - "EndIndex": 33900, - "Kind": 3 - }, - { - "EndIndex": 33906, - "Kind": 3 - }, - { - "EndIndex": 33936, - "Kind": 3 - }, - { - "EndIndex": 33966, - "Kind": 3 - }, - { - "EndIndex": 33988, - "Kind": 3 - }, - { - "EndIndex": 33994, - "Kind": 3 - }, - { - "EndIndex": 34025, - "Kind": 3 - }, - { - "EndIndex": 34055, - "Kind": 3 - }, - { - "EndIndex": 34078, - "Kind": 3 - }, - { - "EndIndex": 34084, - "Kind": 3 - }, - { - "EndIndex": 34114, - "Kind": 3 - }, - { - "EndIndex": 34145, - "Kind": 3 - }, - { - "EndIndex": 34167, - "Kind": 3 - }, - { - "EndIndex": 34173, - "Kind": 3 - }, - { - "EndIndex": 34198, - "Kind": 3 - }, - { - "EndIndex": 34228, - "Kind": 3 - }, - { - "EndIndex": 34247, - "Kind": 3 - }, - { - "EndIndex": 34253, - "Kind": 3 - }, - { - "EndIndex": 34282, - "Kind": 3 - }, - { - "EndIndex": 34334, - "Kind": 3 - }, - { - "EndIndex": 34369, - "Kind": 3 - }, - { - "EndIndex": 34375, - "Kind": 3 - }, - { - "EndIndex": 34407, - "Kind": 3 - }, - { - "EndIndex": 34437, - "Kind": 3 - }, - { - "EndIndex": 34460, - "Kind": 3 - }, - { - "EndIndex": 34466, - "Kind": 3 - }, - { - "EndIndex": 34506, - "Kind": 3 - }, - { - "EndIndex": 34541, - "Kind": 3 - }, - { - "EndIndex": 34562, - "Kind": 3 - }, - { - "EndIndex": 34568, - "Kind": 3 - }, - { - "EndIndex": 34595, - "Kind": 3 - }, - { - "EndIndex": 34655, - "Kind": 3 - }, - { - "EndIndex": 34673, - "Kind": 3 - }, - { - "EndIndex": 34679, - "Kind": 3 - }, - { - "EndIndex": 34697, - "Kind": 3 - }, - { - "EndIndex": 34739, - "Kind": 3 - }, - { - "EndIndex": 35065, - "Kind": 3 - }, - { - "EndIndex": 35087, - "Kind": 3 - }, - { - "EndIndex": 35093, - "Kind": 3 - }, - { - "EndIndex": 35124, - "Kind": 3 - }, - { - "EndIndex": 35173, - "Kind": 3 - }, - { - "EndIndex": 35194, - "Kind": 3 - }, - { - "EndIndex": 35200, - "Kind": 3 - }, - { - "EndIndex": 35222, - "Kind": 3 - }, - { - "EndIndex": 35261, - "Kind": 3 - }, - { - "EndIndex": 35282, - "Kind": 3 - }, - { - "EndIndex": 35288, - "Kind": 3 - }, - { - "EndIndex": 35309, - "Kind": 3 - }, - { - "EndIndex": 35355, - "Kind": 3 - }, - { - "EndIndex": 35378, - "Kind": 3 - }, - { - "EndIndex": 35384, - "Kind": 3 - }, - { - "EndIndex": 35413, - "Kind": 3 - }, - { - "EndIndex": 35463, - "Kind": 3 - }, - { - "EndIndex": 35481, - "Kind": 3 - }, - { - "EndIndex": 35487, - "Kind": 3 - }, - { - "EndIndex": 35520, - "Kind": 3 - }, - { - "EndIndex": 35584, - "Kind": 3 - }, - { - "EndIndex": 35605, - "Kind": 3 - }, - { - "EndIndex": 35611, - "Kind": 3 - }, - { - "EndIndex": 35653, - "Kind": 3 - }, - { - "EndIndex": 35743, - "Kind": 3 - }, - { - "EndIndex": 35761, - "Kind": 3 - }, - { - "EndIndex": 35767, - "Kind": 3 - }, - { - "EndIndex": 35805, - "Kind": 3 - }, - { - "EndIndex": 35844, - "Kind": 3 - }, - { - "EndIndex": 35865, - "Kind": 3 - }, - { - "EndIndex": 35871, - "Kind": 3 - }, - { - "EndIndex": 35898, - "Kind": 3 - }, - { - "EndIndex": 36021, - "Kind": 3 - }, - { - "EndIndex": 36045, - "Kind": 3 - }, - { - "EndIndex": 36051, - "Kind": 3 - }, - { - "EndIndex": 36081, - "Kind": 3 - }, - { - "EndIndex": 36176, - "Kind": 3 - }, - { - "EndIndex": 36197, - "Kind": 3 - }, - { - "EndIndex": 36203, - "Kind": 3 - }, - { - "EndIndex": 36227, - "Kind": 3 - }, - { - "EndIndex": 36258, - "Kind": 3 - }, - { - "EndIndex": 36279, - "Kind": 3 - }, - { - "EndIndex": 36285, - "Kind": 3 - }, - { - "EndIndex": 36306, - "Kind": 3 - }, - { - "EndIndex": 36341, - "Kind": 3 - }, - { - "EndIndex": 36362, - "Kind": 3 - }, - { - "EndIndex": 36368, - "Kind": 3 - }, - { - "EndIndex": 36370, - "Kind": 3 - }, - { - "EndIndex": 36387, - "Kind": 3 - }, - { - "EndIndex": 36408, - "Kind": 3 - }, - { - "EndIndex": 36794, - "Kind": 3 - }, - { - "EndIndex": 36816, - "Kind": 3 - }, - { - "EndIndex": 36850, - "Kind": 3 - }, - { - "EndIndex": 36919, - "Kind": 3 - }, - { - "EndIndex": 36941, - "Kind": 3 - }, - { - "EndIndex": 36947, - "Kind": 3 - }, - { - "EndIndex": 36980, - "Kind": 3 - }, - { - "EndIndex": 37009, - "Kind": 3 - }, - { - "EndIndex": 37030, - "Kind": 3 - }, - { - "EndIndex": 37036, - "Kind": 3 - }, - { - "EndIndex": 37066, - "Kind": 3 - }, - { - "EndIndex": 37097, - "Kind": 3 - }, - { - "EndIndex": 37119, - "Kind": 3 - }, - { - "EndIndex": 37125, - "Kind": 3 - }, - { - "EndIndex": 37155, - "Kind": 3 - }, - { - "EndIndex": 37186, - "Kind": 3 - }, - { - "EndIndex": 37208, - "Kind": 3 - }, - { - "EndIndex": 37214, - "Kind": 3 - }, - { - "EndIndex": 37253, - "Kind": 3 - }, - { - "EndIndex": 37292, - "Kind": 3 - }, - { - "EndIndex": 37306, - "Kind": 3 - }, - { - "EndIndex": 37312, - "Kind": 3 - }, - { - "EndIndex": 37345, - "Kind": 3 - }, - { - "EndIndex": 37383, - "Kind": 3 - }, - { - "EndIndex": 37397, - "Kind": 3 - }, - { - "EndIndex": 37403, - "Kind": 3 - }, - { - "EndIndex": 37433, - "Kind": 3 - }, - { - "EndIndex": 37463, - "Kind": 3 - }, - { - "EndIndex": 37485, - "Kind": 3 - }, - { - "EndIndex": 37491, - "Kind": 3 - }, - { - "EndIndex": 37512, - "Kind": 3 - }, - { - "EndIndex": 37547, - "Kind": 3 - }, - { - "EndIndex": 37937, - "Kind": 3 - }, - { - "EndIndex": 37951, - "Kind": 3 - }, - { - "EndIndex": 37957, - "Kind": 3 - }, - { - "EndIndex": 37975, - "Kind": 3 - }, - { - "EndIndex": 38008, - "Kind": 3 - }, - { - "EndIndex": 38159, - "Kind": 3 - }, - { - "EndIndex": 38180, - "Kind": 3 - }, - { - "EndIndex": 38186, - "Kind": 3 - }, - { - "EndIndex": 38211, - "Kind": 3 - }, - { - "EndIndex": 38244, - "Kind": 3 - }, - { - "EndIndex": 38275, - "Kind": 3 - }, - { - "EndIndex": 38281, - "Kind": 3 - }, - { - "EndIndex": 38311, - "Kind": 3 - }, - { - "EndIndex": 38342, - "Kind": 3 - }, - { - "EndIndex": 38364, - "Kind": 3 - }, - { - "EndIndex": 38370, - "Kind": 3 - }, - { - "EndIndex": 38394, - "Kind": 3 - }, - { - "EndIndex": 38423, - "Kind": 3 - }, - { - "EndIndex": 38441, - "Kind": 3 - }, - { - "EndIndex": 38447, - "Kind": 3 - }, - { - "EndIndex": 38477, - "Kind": 3 - }, - { - "EndIndex": 38507, - "Kind": 3 - }, - { - "EndIndex": 38529, - "Kind": 3 - }, - { - "EndIndex": 38535, - "Kind": 3 - }, - { - "EndIndex": 38565, - "Kind": 3 - }, - { - "EndIndex": 38596, - "Kind": 3 - }, - { - "EndIndex": 38618, - "Kind": 3 - }, - { - "EndIndex": 38624, - "Kind": 3 - }, - { - "EndIndex": 38649, - "Kind": 3 - }, - { - "EndIndex": 38679, - "Kind": 3 - }, - { - "EndIndex": 38698, - "Kind": 3 - }, - { - "EndIndex": 38704, - "Kind": 3 - }, - { - "EndIndex": 38744, - "Kind": 3 - }, - { - "EndIndex": 38779, - "Kind": 3 - }, - { - "EndIndex": 38800, - "Kind": 3 - }, - { - "EndIndex": 38806, - "Kind": 3 - }, - { - "EndIndex": 38833, - "Kind": 3 - }, - { - "EndIndex": 38892, - "Kind": 3 - }, - { - "EndIndex": 38910, - "Kind": 3 - }, - { - "EndIndex": 38916, - "Kind": 3 - }, - { - "EndIndex": 38934, - "Kind": 3 - }, - { - "EndIndex": 38976, - "Kind": 3 - }, - { - "EndIndex": 39302, - "Kind": 3 - }, - { - "EndIndex": 39324, - "Kind": 3 - }, - { - "EndIndex": 39330, - "Kind": 3 - }, - { - "EndIndex": 39352, - "Kind": 3 - }, - { - "EndIndex": 39408, - "Kind": 3 - }, - { - "EndIndex": 39429, - "Kind": 3 - }, - { - "EndIndex": 39435, - "Kind": 3 - }, - { - "EndIndex": 39456, - "Kind": 3 - }, - { - "EndIndex": 39499, - "Kind": 3 - }, - { - "EndIndex": 39522, - "Kind": 3 - }, - { - "EndIndex": 39528, - "Kind": 3 - }, - { - "EndIndex": 39546, - "Kind": 3 - }, - { - "EndIndex": 39593, - "Kind": 3 - }, - { - "EndIndex": 39677, - "Kind": 3 - }, - { - "EndIndex": 39696, - "Kind": 3 - }, - { - "EndIndex": 39702, - "Kind": 3 - }, - { - "EndIndex": 39736, - "Kind": 3 - }, - { - "EndIndex": 39815, - "Kind": 3 - }, - { - "EndIndex": 39839, - "Kind": 3 - }, - { - "EndIndex": 39845, - "Kind": 3 - }, - { - "EndIndex": 39867, - "Kind": 3 - }, - { - "EndIndex": 39939, - "Kind": 3 - }, - { - "EndIndex": 39971, - "Kind": 3 - }, - { - "EndIndex": 39977, - "Kind": 3 - }, - { - "EndIndex": 39998, - "Kind": 3 - }, - { - "EndIndex": 40068, - "Kind": 3 - }, - { - "EndIndex": 40099, - "Kind": 3 - }, - { - "EndIndex": 40105, - "Kind": 3 - }, - { - "EndIndex": 40136, - "Kind": 3 - }, - { - "EndIndex": 40298, - "Kind": 3 - }, - { - "EndIndex": 40329, - "Kind": 3 - }, - { - "EndIndex": 40335, - "Kind": 3 - }, - { - "EndIndex": 40370, - "Kind": 3 - }, - { - "EndIndex": 40494, - "Kind": 3 - }, - { - "EndIndex": 40526, - "Kind": 3 - }, - { - "EndIndex": 40532, - "Kind": 3 - }, - { - "EndIndex": 40573, - "Kind": 3 - }, - { - "EndIndex": 40723, - "Kind": 3 - }, - { - "EndIndex": 40747, - "Kind": 3 - }, - { - "EndIndex": 40753, - "Kind": 3 - }, - { - "EndIndex": 40779, - "Kind": 3 - }, - { - "EndIndex": 41079, - "Kind": 3 - }, - { - "EndIndex": 41100, - "Kind": 3 - }, - { - "EndIndex": 41106, - "Kind": 3 - }, - { - "EndIndex": 41129, - "Kind": 3 - }, - { - "EndIndex": 41195, - "Kind": 3 - }, - { - "EndIndex": 41228, - "Kind": 3 - }, - { - "EndIndex": 41234, - "Kind": 3 - }, - { - "EndIndex": 41236, - "Kind": 3 - }, - { - "EndIndex": 41253, - "Kind": 3 - }, - { - "EndIndex": 41273, - "Kind": 3 - }, - { - "EndIndex": 41396, - "Kind": 3 - }, - { - "EndIndex": 41427, - "Kind": 3 - }, - { - "EndIndex": 41457, - "Kind": 3 - }, - { - "EndIndex": 41479, - "Kind": 3 - }, - { - "EndIndex": 41485, - "Kind": 3 - }, - { - "EndIndex": 41506, - "Kind": 3 - }, - { - "EndIndex": 41542, - "Kind": 3 - }, - { - "EndIndex": 41584, - "Kind": 3 - }, - { - "EndIndex": 41606, - "Kind": 3 - }, - { - "EndIndex": 41612, - "Kind": 3 - }, - { - "EndIndex": 41642, - "Kind": 3 - }, - { - "EndIndex": 41673, - "Kind": 3 - }, - { - "EndIndex": 41695, - "Kind": 3 - }, - { - "EndIndex": 41701, - "Kind": 3 - }, - { - "EndIndex": 41731, - "Kind": 3 - }, - { - "EndIndex": 41762, - "Kind": 3 - }, - { - "EndIndex": 41784, - "Kind": 3 - }, - { - "EndIndex": 41790, - "Kind": 3 - }, - { - "EndIndex": 41829, - "Kind": 3 - }, - { - "EndIndex": 41868, - "Kind": 3 - }, - { - "EndIndex": 41882, - "Kind": 3 - }, - { - "EndIndex": 41888, - "Kind": 3 - }, - { - "EndIndex": 41918, - "Kind": 3 - }, - { - "EndIndex": 41948, - "Kind": 3 - }, - { - "EndIndex": 41970, - "Kind": 3 - }, - { - "EndIndex": 41976, - "Kind": 3 - }, - { - "EndIndex": 41997, - "Kind": 3 - }, - { - "EndIndex": 42029, - "Kind": 3 - }, - { - "EndIndex": 42060, - "Kind": 3 - }, - { - "EndIndex": 42081, - "Kind": 3 - }, - { - "EndIndex": 42087, - "Kind": 3 - }, - { - "EndIndex": 42122, - "Kind": 3 - }, - { - "EndIndex": 42249, - "Kind": 3 - }, - { - "EndIndex": 42263, - "Kind": 3 - }, - { - "EndIndex": 42269, - "Kind": 3 - }, - { - "EndIndex": 42287, - "Kind": 3 - }, - { - "EndIndex": 42320, - "Kind": 3 - }, - { - "EndIndex": 42471, - "Kind": 3 - }, - { - "EndIndex": 42492, - "Kind": 3 - }, - { - "EndIndex": 42498, - "Kind": 3 - }, - { - "EndIndex": 42529, - "Kind": 3 - }, - { - "EndIndex": 42560, - "Kind": 3 - }, - { - "EndIndex": 42581, - "Kind": 3 - }, - { - "EndIndex": 42587, - "Kind": 3 - }, - { - "EndIndex": 42619, - "Kind": 3 - }, - { - "EndIndex": 42650, - "Kind": 3 - }, - { - "EndIndex": 42671, - "Kind": 3 - }, - { - "EndIndex": 42677, - "Kind": 3 - }, - { - "EndIndex": 42702, - "Kind": 3 - }, - { - "EndIndex": 42735, - "Kind": 3 - }, - { - "EndIndex": 42769, - "Kind": 3 - }, - { - "EndIndex": 42775, - "Kind": 3 - }, - { - "EndIndex": 42807, - "Kind": 3 - }, - { - "EndIndex": 42838, - "Kind": 3 - }, - { - "EndIndex": 42859, - "Kind": 3 - }, - { - "EndIndex": 42865, - "Kind": 3 - }, - { - "EndIndex": 42895, - "Kind": 3 - }, - { - "EndIndex": 42926, - "Kind": 3 - }, - { - "EndIndex": 42948, - "Kind": 3 - }, - { - "EndIndex": 42954, - "Kind": 3 - }, - { - "EndIndex": 42978, - "Kind": 3 - }, - { - "EndIndex": 43007, - "Kind": 3 - }, - { - "EndIndex": 43025, - "Kind": 3 - }, - { - "EndIndex": 43031, - "Kind": 3 - }, - { - "EndIndex": 43061, - "Kind": 3 - }, - { - "EndIndex": 43091, - "Kind": 3 - }, - { - "EndIndex": 43113, - "Kind": 3 - }, - { - "EndIndex": 43119, - "Kind": 3 - }, - { - "EndIndex": 43149, - "Kind": 3 - }, - { - "EndIndex": 43180, - "Kind": 3 - }, - { - "EndIndex": 43202, - "Kind": 3 - }, - { - "EndIndex": 43208, - "Kind": 3 - }, - { - "EndIndex": 43238, - "Kind": 3 - }, - { - "EndIndex": 43268, - "Kind": 3 - }, - { - "EndIndex": 43290, - "Kind": 3 - }, - { - "EndIndex": 43296, - "Kind": 3 - }, - { - "EndIndex": 43328, - "Kind": 3 - }, - { - "EndIndex": 43358, - "Kind": 3 - }, - { - "EndIndex": 43380, - "Kind": 3 - }, - { - "EndIndex": 43386, - "Kind": 3 - }, - { - "EndIndex": 43413, - "Kind": 3 - }, - { - "EndIndex": 43463, - "Kind": 3 - }, - { - "EndIndex": 43493, - "Kind": 3 - }, - { - "EndIndex": 43499, - "Kind": 3 - }, - { - "EndIndex": 43524, - "Kind": 3 - }, - { - "EndIndex": 43554, - "Kind": 3 - }, - { - "EndIndex": 43573, - "Kind": 3 - }, - { - "EndIndex": 43579, - "Kind": 3 - }, - { - "EndIndex": 43610, - "Kind": 3 - }, - { - "EndIndex": 43640, - "Kind": 3 - }, - { - "EndIndex": 43662, - "Kind": 3 - }, - { - "EndIndex": 43668, - "Kind": 3 - }, - { - "EndIndex": 43700, - "Kind": 3 - }, - { - "EndIndex": 43730, - "Kind": 3 - }, - { - "EndIndex": 43752, - "Kind": 3 - }, - { - "EndIndex": 43758, - "Kind": 3 - }, - { - "EndIndex": 43790, - "Kind": 3 - }, - { - "EndIndex": 43820, - "Kind": 3 - }, - { - "EndIndex": 43842, - "Kind": 3 - }, - { - "EndIndex": 43848, - "Kind": 3 - }, - { - "EndIndex": 43875, - "Kind": 3 - }, - { - "EndIndex": 43934, - "Kind": 3 - }, - { - "EndIndex": 43952, - "Kind": 3 - }, - { - "EndIndex": 43958, - "Kind": 3 - }, - { - "EndIndex": 43989, - "Kind": 3 - }, - { - "EndIndex": 44019, - "Kind": 3 - }, - { - "EndIndex": 44041, - "Kind": 3 - }, - { - "EndIndex": 44047, - "Kind": 3 - }, - { - "EndIndex": 44065, - "Kind": 3 - }, - { - "EndIndex": 44107, - "Kind": 3 - }, - { - "EndIndex": 44433, - "Kind": 3 - }, - { - "EndIndex": 44455, - "Kind": 3 - }, - { - "EndIndex": 44461, - "Kind": 3 - }, - { - "EndIndex": 44492, - "Kind": 3 - }, - { - "EndIndex": 44522, - "Kind": 3 - }, - { - "EndIndex": 44544, - "Kind": 3 - }, - { - "EndIndex": 44550, - "Kind": 3 - }, - { - "EndIndex": 44577, - "Kind": 3 - }, - { - "EndIndex": 44670, - "Kind": 3 - }, - { - "EndIndex": 44691, - "Kind": 3 - }, - { - "EndIndex": 44697, - "Kind": 3 - }, - { - "EndIndex": 44719, - "Kind": 3 - }, - { - "EndIndex": 44765, - "Kind": 3 - }, - { - "EndIndex": 44786, - "Kind": 3 - }, - { - "EndIndex": 44792, - "Kind": 3 - }, - { - "EndIndex": 44813, - "Kind": 3 - }, - { - "EndIndex": 44856, - "Kind": 3 - }, - { - "EndIndex": 44878, - "Kind": 3 - }, - { - "EndIndex": 44884, - "Kind": 3 - }, - { - "EndIndex": 44918, - "Kind": 3 - }, - { - "EndIndex": 45049, - "Kind": 3 - }, - { - "EndIndex": 45071, - "Kind": 3 - }, - { - "EndIndex": 45077, - "Kind": 3 - }, - { - "EndIndex": 45120, - "Kind": 3 - }, - { - "EndIndex": 45181, - "Kind": 3 - }, - { - "EndIndex": 45202, - "Kind": 3 - }, - { - "EndIndex": 45208, - "Kind": 3 - }, - { - "EndIndex": 45238, - "Kind": 3 - }, - { - "EndIndex": 45344, - "Kind": 3 - }, - { - "EndIndex": 45365, - "Kind": 3 - }, - { - "EndIndex": 45371, - "Kind": 3 - }, - { - "EndIndex": 45407, - "Kind": 3 - }, - { - "EndIndex": 45514, - "Kind": 3 - }, - { - "EndIndex": 45536, - "Kind": 3 - }, - { - "EndIndex": 45542, - "Kind": 3 - }, - { - "EndIndex": 45587, - "Kind": 3 - }, - { - "EndIndex": 45656, - "Kind": 3 - }, - { - "EndIndex": 45677, - "Kind": 3 - }, - { - "EndIndex": 45683, - "Kind": 3 - }, - { - "EndIndex": 45717, - "Kind": 3 - }, - { - "EndIndex": 45778, - "Kind": 3 - }, - { - "EndIndex": 45800, - "Kind": 3 - }, - { - "EndIndex": 45806, - "Kind": 3 - }, - { - "EndIndex": 45838, - "Kind": 3 - }, - { - "EndIndex": 45895, - "Kind": 3 - }, - { - "EndIndex": 45917, - "Kind": 3 - }, - { - "EndIndex": 45923, - "Kind": 3 - }, - { - "EndIndex": 45957, - "Kind": 3 - }, - { - "EndIndex": 46014, - "Kind": 3 - }, - { - "EndIndex": 46036, - "Kind": 3 - }, - { - "EndIndex": 46042, - "Kind": 3 - }, - { - "EndIndex": 46062, - "Kind": 3 - }, - { - "EndIndex": 46155, - "Kind": 3 - }, - { - "EndIndex": 46169, - "Kind": 3 - }, - { - "EndIndex": 46175, - "Kind": 3 - }, - { - "EndIndex": 46204, - "Kind": 3 - }, - { - "EndIndex": 46319, - "Kind": 3 - }, - { - "EndIndex": 46340, - "Kind": 3 - }, - { - "EndIndex": 46346, - "Kind": 3 - }, - { - "EndIndex": 46390, - "Kind": 3 - }, - { - "EndIndex": 46519, - "Kind": 3 - }, - { - "EndIndex": 46541, - "Kind": 3 - }, - { - "EndIndex": 46547, - "Kind": 3 - }, - { - "EndIndex": 46600, - "Kind": 3 - }, - { - "EndIndex": 46677, - "Kind": 3 - }, - { - "EndIndex": 46698, - "Kind": 3 - }, - { - "EndIndex": 46704, - "Kind": 3 - }, - { - "EndIndex": 46735, - "Kind": 3 - }, - { - "EndIndex": 46832, - "Kind": 3 - }, - { - "EndIndex": 46854, - "Kind": 3 - }, - { - "EndIndex": 46860, - "Kind": 3 - }, - { - "EndIndex": 46892, - "Kind": 3 - }, - { - "EndIndex": 46953, - "Kind": 3 - }, - { - "EndIndex": 46974, - "Kind": 3 - }, - { - "EndIndex": 46980, - "Kind": 3 - }, - { - "EndIndex": 46982, - "Kind": 3 - }, - { - "EndIndex": 46997, - "Kind": 3 - }, - { - "EndIndex": 47023, - "Kind": 3 - }, - { - "EndIndex": 47172, - "Kind": 3 - }, - { - "EndIndex": 47203, - "Kind": 3 - }, - { - "EndIndex": 47233, - "Kind": 3 - }, - { - "EndIndex": 47261, - "Kind": 3 - }, - { - "EndIndex": 47267, - "Kind": 3 - }, - { - "EndIndex": 47294, - "Kind": 3 - }, - { - "EndIndex": 47330, - "Kind": 3 - }, - { - "EndIndex": 47372, - "Kind": 3 - }, - { - "EndIndex": 47394, - "Kind": 3 - }, - { - "EndIndex": 47400, - "Kind": 3 - }, - { - "EndIndex": 47430, - "Kind": 3 - }, - { - "EndIndex": 47461, - "Kind": 3 - }, - { - "EndIndex": 47483, - "Kind": 3 - }, - { - "EndIndex": 47489, - "Kind": 3 - }, - { - "EndIndex": 47519, - "Kind": 3 - }, - { - "EndIndex": 47550, - "Kind": 3 - }, - { - "EndIndex": 47572, - "Kind": 3 - }, - { - "EndIndex": 47578, - "Kind": 3 - }, - { - "EndIndex": 47617, - "Kind": 3 - }, - { - "EndIndex": 47656, - "Kind": 3 - }, - { - "EndIndex": 47670, - "Kind": 3 - }, - { - "EndIndex": 47676, - "Kind": 3 - }, - { - "EndIndex": 47706, - "Kind": 3 - }, - { - "EndIndex": 47736, - "Kind": 3 - }, - { - "EndIndex": 47758, - "Kind": 3 - }, - { - "EndIndex": 47764, - "Kind": 3 - }, - { - "EndIndex": 47789, - "Kind": 3 - }, - { - "EndIndex": 47819, - "Kind": 3 - }, - { - "EndIndex": 47837, - "Kind": 3 - }, - { - "EndIndex": 47843, - "Kind": 3 - }, - { - "EndIndex": 47878, - "Kind": 3 - }, - { - "EndIndex": 48031, - "Kind": 3 - }, - { - "EndIndex": 48045, - "Kind": 3 - }, - { - "EndIndex": 48051, - "Kind": 3 - }, - { - "EndIndex": 48069, - "Kind": 3 - }, - { - "EndIndex": 48102, - "Kind": 3 - }, - { - "EndIndex": 48253, - "Kind": 3 - }, - { - "EndIndex": 48274, - "Kind": 3 - }, - { - "EndIndex": 48280, - "Kind": 3 - }, - { - "EndIndex": 48305, - "Kind": 3 - }, - { - "EndIndex": 48338, - "Kind": 3 - }, - { - "EndIndex": 48372, - "Kind": 3 - }, - { - "EndIndex": 48378, - "Kind": 3 - }, - { - "EndIndex": 48408, - "Kind": 3 - }, - { - "EndIndex": 48439, - "Kind": 3 - }, - { - "EndIndex": 48461, - "Kind": 3 - }, - { - "EndIndex": 48467, - "Kind": 3 - }, - { - "EndIndex": 48491, - "Kind": 3 - }, - { - "EndIndex": 48520, - "Kind": 3 - }, - { - "EndIndex": 48538, - "Kind": 3 - }, - { - "EndIndex": 48544, - "Kind": 3 - }, - { - "EndIndex": 48574, - "Kind": 3 - }, - { - "EndIndex": 48604, - "Kind": 3 - }, - { - "EndIndex": 48626, - "Kind": 3 - }, - { - "EndIndex": 48632, - "Kind": 3 - }, - { - "EndIndex": 48662, - "Kind": 3 - }, - { - "EndIndex": 48693, - "Kind": 3 - }, - { - "EndIndex": 48715, - "Kind": 3 - }, - { - "EndIndex": 48721, - "Kind": 3 - }, - { - "EndIndex": 48751, - "Kind": 3 - }, - { - "EndIndex": 48781, - "Kind": 3 - }, - { - "EndIndex": 48809, - "Kind": 3 - }, - { - "EndIndex": 48815, - "Kind": 3 - }, - { - "EndIndex": 48847, - "Kind": 3 - }, - { - "EndIndex": 48877, - "Kind": 3 - }, - { - "EndIndex": 48905, - "Kind": 3 - }, - { - "EndIndex": 48911, - "Kind": 3 - }, - { - "EndIndex": 48938, - "Kind": 3 - }, - { - "EndIndex": 48988, - "Kind": 3 - }, - { - "EndIndex": 49018, - "Kind": 3 - }, - { - "EndIndex": 49024, - "Kind": 3 - }, - { - "EndIndex": 49049, - "Kind": 3 - }, - { - "EndIndex": 49079, - "Kind": 3 - }, - { - "EndIndex": 49098, - "Kind": 3 - }, - { - "EndIndex": 49104, - "Kind": 3 - }, - { - "EndIndex": 49135, - "Kind": 3 - }, - { - "EndIndex": 49165, - "Kind": 3 - }, - { - "EndIndex": 49193, - "Kind": 3 - }, - { - "EndIndex": 49199, - "Kind": 3 - }, - { - "EndIndex": 49231, - "Kind": 3 - }, - { - "EndIndex": 49261, - "Kind": 3 - }, - { - "EndIndex": 49289, - "Kind": 3 - }, - { - "EndIndex": 49295, - "Kind": 3 - }, - { - "EndIndex": 49327, - "Kind": 3 - }, - { - "EndIndex": 49357, - "Kind": 3 - }, - { - "EndIndex": 49385, - "Kind": 3 - }, - { - "EndIndex": 49391, - "Kind": 3 - }, - { - "EndIndex": 49418, - "Kind": 3 - }, - { - "EndIndex": 49477, - "Kind": 3 - }, - { - "EndIndex": 49495, - "Kind": 3 - }, - { - "EndIndex": 49501, - "Kind": 3 - }, - { - "EndIndex": 49532, - "Kind": 3 - }, - { - "EndIndex": 49562, - "Kind": 3 - }, - { - "EndIndex": 49590, - "Kind": 3 - }, - { - "EndIndex": 49596, - "Kind": 3 - }, - { - "EndIndex": 49614, - "Kind": 3 - }, - { - "EndIndex": 49656, - "Kind": 3 - }, - { - "EndIndex": 49982, - "Kind": 3 - }, - { - "EndIndex": 50004, - "Kind": 3 - }, - { - "EndIndex": 50010, - "Kind": 3 - }, - { - "EndIndex": 50041, - "Kind": 3 - }, - { - "EndIndex": 50071, - "Kind": 3 - }, - { - "EndIndex": 50099, - "Kind": 3 - }, - { - "EndIndex": 50105, - "Kind": 3 - }, - { - "EndIndex": 50126, - "Kind": 3 - }, - { - "EndIndex": 50169, - "Kind": 3 - }, - { - "EndIndex": 50197, - "Kind": 3 - }, - { - "EndIndex": 50203, - "Kind": 3 - }, - { - "EndIndex": 50237, - "Kind": 3 - }, - { - "EndIndex": 50368, - "Kind": 3 - }, - { - "EndIndex": 50396, - "Kind": 3 - }, - { - "EndIndex": 50402, - "Kind": 3 - }, - { - "EndIndex": 50438, - "Kind": 3 - }, - { - "EndIndex": 50545, - "Kind": 3 - }, - { - "EndIndex": 50573, - "Kind": 3 - }, - { - "EndIndex": 50579, - "Kind": 3 - }, - { - "EndIndex": 50613, - "Kind": 3 - }, - { - "EndIndex": 50674, - "Kind": 3 - }, - { - "EndIndex": 50696, - "Kind": 3 - }, - { - "EndIndex": 50702, - "Kind": 3 - }, - { - "EndIndex": 50734, - "Kind": 3 - }, - { - "EndIndex": 50791, - "Kind": 3 - }, - { - "EndIndex": 50813, - "Kind": 3 - }, - { - "EndIndex": 50819, - "Kind": 3 - }, - { - "EndIndex": 50853, - "Kind": 3 - }, - { - "EndIndex": 50910, - "Kind": 3 - }, - { - "EndIndex": 50932, - "Kind": 3 - }, - { - "EndIndex": 50938, - "Kind": 3 - }, - { - "EndIndex": 50982, - "Kind": 3 - }, - { - "EndIndex": 51111, - "Kind": 3 - }, - { - "EndIndex": 51139, - "Kind": 3 - }, - { - "EndIndex": 51145, - "Kind": 3 - }, - { - "EndIndex": 51176, - "Kind": 3 - }, - { - "EndIndex": 51273, - "Kind": 3 - }, - { - "EndIndex": 51301, - "Kind": 3 - }, - { - "EndIndex": 51307, - "Kind": 3 - }, - { - "EndIndex": 51309, - "Kind": 3 - }, - { - "EndIndex": 51336, - "Kind": 3 - }, - { - "EndIndex": 51358, - "Kind": 3 - }, - { - "EndIndex": 51834, - "Kind": 3 - }, - { - "EndIndex": 51865, - "Kind": 3 - }, - { - "EndIndex": 51895, - "Kind": 3 - }, - { - "EndIndex": 51919, - "Kind": 3 - }, - { - "EndIndex": 51925, - "Kind": 3 - }, - { - "EndIndex": 51948, - "Kind": 3 - }, - { - "EndIndex": 51982, - "Kind": 3 - }, - { - "EndIndex": 52013, - "Kind": 3 - }, - { - "EndIndex": 52035, - "Kind": 3 - }, - { - "EndIndex": 52041, - "Kind": 3 - }, - { - "EndIndex": 52071, - "Kind": 3 - }, - { - "EndIndex": 52102, - "Kind": 3 - }, - { - "EndIndex": 52124, - "Kind": 3 - }, - { - "EndIndex": 52130, - "Kind": 3 - }, - { - "EndIndex": 52160, - "Kind": 3 - }, - { - "EndIndex": 52191, - "Kind": 3 - }, - { - "EndIndex": 52213, - "Kind": 3 - }, - { - "EndIndex": 52219, - "Kind": 3 - }, - { - "EndIndex": 52258, - "Kind": 3 - }, - { - "EndIndex": 52297, - "Kind": 3 - }, - { - "EndIndex": 52311, - "Kind": 3 - }, - { - "EndIndex": 52317, - "Kind": 3 - }, - { - "EndIndex": 52350, - "Kind": 3 - }, - { - "EndIndex": 52379, - "Kind": 3 - }, - { - "EndIndex": 52403, - "Kind": 3 - }, - { - "EndIndex": 52409, - "Kind": 3 - }, - { - "EndIndex": 52440, - "Kind": 3 - }, - { - "EndIndex": 52459, - "Kind": 3 - }, - { - "EndIndex": 52465, - "Kind": 3 - }, - { - "EndIndex": 52495, - "Kind": 3 - }, - { - "EndIndex": 52525, - "Kind": 3 - }, - { - "EndIndex": 52547, - "Kind": 3 - }, - { - "EndIndex": 52553, - "Kind": 3 - }, - { - "EndIndex": 52578, - "Kind": 3 - }, - { - "EndIndex": 52608, - "Kind": 3 - }, - { - "EndIndex": 52626, - "Kind": 3 - }, - { - "EndIndex": 52632, - "Kind": 3 - }, - { - "EndIndex": 52688, - "Kind": 3 - }, - { - "EndIndex": 53168, - "Kind": 3 - }, - { - "EndIndex": 53182, - "Kind": 3 - }, - { - "EndIndex": 53188, - "Kind": 3 - }, - { - "EndIndex": 53206, - "Kind": 3 - }, - { - "EndIndex": 53239, - "Kind": 3 - }, - { - "EndIndex": 53390, - "Kind": 3 - }, - { - "EndIndex": 53411, - "Kind": 3 - }, - { - "EndIndex": 53417, - "Kind": 3 - }, - { - "EndIndex": 53442, - "Kind": 3 - }, - { - "EndIndex": 53475, - "Kind": 3 - }, - { - "EndIndex": 53511, - "Kind": 3 - }, - { - "EndIndex": 53517, - "Kind": 3 - }, - { - "EndIndex": 53547, - "Kind": 3 - }, - { - "EndIndex": 53578, - "Kind": 3 - }, - { - "EndIndex": 53600, - "Kind": 3 - }, - { - "EndIndex": 53606, - "Kind": 3 - }, - { - "EndIndex": 53630, - "Kind": 3 - }, - { - "EndIndex": 53659, - "Kind": 3 - }, - { - "EndIndex": 53677, - "Kind": 3 - }, - { - "EndIndex": 53683, - "Kind": 3 - }, - { - "EndIndex": 53713, - "Kind": 3 - }, - { - "EndIndex": 53743, - "Kind": 3 - }, - { - "EndIndex": 53765, - "Kind": 3 - }, - { - "EndIndex": 53771, - "Kind": 3 - }, - { - "EndIndex": 53802, - "Kind": 3 - }, - { - "EndIndex": 53832, - "Kind": 3 - }, - { - "EndIndex": 53856, - "Kind": 3 - }, - { - "EndIndex": 53862, - "Kind": 3 - }, - { - "EndIndex": 53893, - "Kind": 3 - }, - { - "EndIndex": 53923, - "Kind": 3 - }, - { - "EndIndex": 53947, - "Kind": 3 - }, - { - "EndIndex": 53953, - "Kind": 3 - }, - { - "EndIndex": 53983, - "Kind": 3 - }, - { - "EndIndex": 54014, - "Kind": 3 - }, - { - "EndIndex": 54036, - "Kind": 3 - }, - { - "EndIndex": 54042, - "Kind": 3 - }, - { - "EndIndex": 54067, - "Kind": 3 - }, - { - "EndIndex": 54097, - "Kind": 3 - }, - { - "EndIndex": 54116, - "Kind": 3 - }, - { - "EndIndex": 54122, - "Kind": 3 - }, - { - "EndIndex": 54154, - "Kind": 3 - }, - { - "EndIndex": 54184, - "Kind": 3 - }, - { - "EndIndex": 54208, - "Kind": 3 - }, - { - "EndIndex": 54214, - "Kind": 3 - }, - { - "EndIndex": 54246, - "Kind": 3 - }, - { - "EndIndex": 54276, - "Kind": 3 - }, - { - "EndIndex": 54300, - "Kind": 3 - }, - { - "EndIndex": 54306, - "Kind": 3 - }, - { - "EndIndex": 54330, - "Kind": 3 - }, - { - "EndIndex": 54359, - "Kind": 3 - }, - { - "EndIndex": 54378, - "Kind": 3 - }, - { - "EndIndex": 54384, - "Kind": 3 - }, - { - "EndIndex": 54402, - "Kind": 3 - }, - { - "EndIndex": 54444, - "Kind": 3 - }, - { - "EndIndex": 54770, - "Kind": 3 - }, - { - "EndIndex": 54792, - "Kind": 3 - }, - { - "EndIndex": 54798, - "Kind": 3 - }, - { - "EndIndex": 54825, - "Kind": 3 - }, - { - "EndIndex": 54963, - "Kind": 3 - }, - { - "EndIndex": 54987, - "Kind": 3 - }, - { - "EndIndex": 54993, - "Kind": 3 - }, - { - "EndIndex": 55038, - "Kind": 3 - }, - { - "EndIndex": 55215, - "Kind": 3 - }, - { - "EndIndex": 55239, - "Kind": 3 - }, - { - "EndIndex": 55245, - "Kind": 3 - }, - { - "EndIndex": 55289, - "Kind": 3 - }, - { - "EndIndex": 55503, - "Kind": 3 - }, - { - "EndIndex": 55521, - "Kind": 3 - }, - { - "EndIndex": 55527, - "Kind": 3 - }, - { - "EndIndex": 55568, - "Kind": 3 - }, - { - "EndIndex": 56037, - "Kind": 3 - }, - { - "EndIndex": 56056, - "Kind": 3 - }, - { - "EndIndex": 56062, - "Kind": 3 - }, - { - "EndIndex": 56112, - "Kind": 3 - }, - { - "EndIndex": 56392, - "Kind": 3 - }, - { - "EndIndex": 56414, - "Kind": 3 - }, - { - "EndIndex": 56420, - "Kind": 3 - }, - { - "EndIndex": 56458, - "Kind": 3 - }, - { - "EndIndex": 56645, - "Kind": 3 - }, - { - "EndIndex": 56669, - "Kind": 3 - }, - { - "EndIndex": 56675, - "Kind": 3 - }, - { - "EndIndex": 56718, - "Kind": 3 - }, - { - "EndIndex": 56974, - "Kind": 3 - }, - { - "EndIndex": 56992, - "Kind": 3 - }, - { - "EndIndex": 56998, - "Kind": 3 - }, - { - "EndIndex": 57016, - "Kind": 3 - }, - { - "EndIndex": 57053, - "Kind": 3 - }, - { - "EndIndex": 57232, - "Kind": 3 - }, - { - "EndIndex": 57252, - "Kind": 3 - }, - { - "EndIndex": 57258, - "Kind": 3 - }, - { - "EndIndex": 57278, - "Kind": 3 - }, - { - "EndIndex": 57418, - "Kind": 3 - }, - { - "EndIndex": 57437, - "Kind": 3 - }, - { - "EndIndex": 57443, - "Kind": 3 - }, - { - "EndIndex": 57487, - "Kind": 3 - }, - { - "EndIndex": 57774, - "Kind": 3 - }, - { - "EndIndex": 57792, - "Kind": 3 - }, - { - "EndIndex": 57798, - "Kind": 3 - }, - { - "EndIndex": 57822, - "Kind": 3 - }, - { - "EndIndex": 57968, - "Kind": 3 - }, - { - "EndIndex": 57990, - "Kind": 3 - }, - { - "EndIndex": 57996, - "Kind": 3 - }, - { - "EndIndex": 58020, - "Kind": 3 - }, - { - "EndIndex": 58164, - "Kind": 3 - }, - { - "EndIndex": 58186, - "Kind": 3 - }, - { - "EndIndex": 58192, - "Kind": 3 - }, - { - "EndIndex": 58216, - "Kind": 3 - }, - { - "EndIndex": 58328, - "Kind": 3 - }, - { - "EndIndex": 58349, - "Kind": 3 - }, - { - "EndIndex": 58355, - "Kind": 3 - }, - { - "EndIndex": 58379, - "Kind": 3 - }, - { - "EndIndex": 58519, - "Kind": 3 - }, - { - "EndIndex": 58541, - "Kind": 3 - }, - { - "EndIndex": 58547, - "Kind": 3 - }, - { - "EndIndex": 58571, - "Kind": 3 - }, - { - "EndIndex": 58726, - "Kind": 3 - }, - { - "EndIndex": 58748, - "Kind": 3 - }, - { - "EndIndex": 58754, - "Kind": 3 - }, - { - "EndIndex": 58778, - "Kind": 3 - }, - { - "EndIndex": 58922, - "Kind": 3 - }, - { - "EndIndex": 58944, - "Kind": 3 - }, - { - "EndIndex": 58950, - "Kind": 3 - }, - { - "EndIndex": 58974, - "Kind": 3 - }, - { - "EndIndex": 59220, - "Kind": 3 - }, - { - "EndIndex": 59242, - "Kind": 3 - }, - { - "EndIndex": 59248, - "Kind": 3 - }, - { - "EndIndex": 59272, - "Kind": 3 - }, - { - "EndIndex": 59427, - "Kind": 3 - }, - { - "EndIndex": 59449, - "Kind": 3 - }, - { - "EndIndex": 59455, - "Kind": 3 - }, - { - "EndIndex": 59495, - "Kind": 3 - }, - { - "EndIndex": 59727, - "Kind": 3 - }, - { - "EndIndex": 59747, - "Kind": 3 - }, - { - "EndIndex": 59753, - "Kind": 3 - }, - { - "EndIndex": 59797, - "Kind": 3 - }, - { - "EndIndex": 59978, - "Kind": 3 - }, - { - "EndIndex": 60002, - "Kind": 3 - }, - { - "EndIndex": 60008, - "Kind": 3 - }, - { - "EndIndex": 60030, - "Kind": 3 - }, - { - "EndIndex": 60136, - "Kind": 3 - }, - { - "EndIndex": 60160, - "Kind": 3 - }, - { - "EndIndex": 60166, - "Kind": 3 - }, - { - "EndIndex": 60196, - "Kind": 3 - }, - { - "EndIndex": 60326, - "Kind": 3 - }, - { - "EndIndex": 60350, - "Kind": 3 - }, - { - "EndIndex": 60356, - "Kind": 3 - }, - { - "EndIndex": 60374, - "Kind": 3 - }, - { - "EndIndex": 60408, - "Kind": 3 - }, - { - "EndIndex": 60667, - "Kind": 3 - }, - { - "EndIndex": 60687, - "Kind": 3 - }, - { - "EndIndex": 60693, - "Kind": 3 - }, - { - "EndIndex": 60724, - "Kind": 3 - }, - { - "EndIndex": 61108, - "Kind": 3 - }, - { - "EndIndex": 61152, - "Kind": 3 - }, - { - "EndIndex": 61158, - "Kind": 3 - }, - { - "EndIndex": 61199, - "Kind": 3 - }, - { - "EndIndex": 61488, - "Kind": 3 - }, - { - "EndIndex": 61512, - "Kind": 3 - }, - { - "EndIndex": 61518, - "Kind": 3 - }, - { - "EndIndex": 61562, - "Kind": 3 - }, - { - "EndIndex": 61820, - "Kind": 3 - }, - { - "EndIndex": 61838, - "Kind": 3 - }, - { - "EndIndex": 61844, - "Kind": 3 - }, - { - "EndIndex": 61889, - "Kind": 3 - }, - { - "EndIndex": 62177, - "Kind": 3 - }, - { - "EndIndex": 62195, - "Kind": 3 - }, - { - "EndIndex": 62201, - "Kind": 3 - }, - { - "EndIndex": 62245, - "Kind": 3 - }, - { - "EndIndex": 62426, - "Kind": 3 - }, - { - "EndIndex": 62450, - "Kind": 3 - }, - { - "EndIndex": 62456, - "Kind": 3 - }, - { - "EndIndex": 62488, - "Kind": 3 - }, - { - "EndIndex": 62893, - "Kind": 3 - }, - { - "EndIndex": 62937, - "Kind": 3 - }, - { - "EndIndex": 62943, - "Kind": 3 - }, - { - "EndIndex": 62981, - "Kind": 3 - }, - { - "EndIndex": 63434, - "Kind": 3 - }, - { - "EndIndex": 63460, - "Kind": 3 - }, - { - "EndIndex": 63466, - "Kind": 3 - }, - { - "EndIndex": 63496, - "Kind": 3 - }, - { - "EndIndex": 63627, - "Kind": 3 - }, - { - "EndIndex": 63651, - "Kind": 3 - }, - { - "EndIndex": 63657, - "Kind": 3 - }, - { - "EndIndex": 63694, - "Kind": 3 - }, - { - "EndIndex": 64067, - "Kind": 3 - }, - { - "EndIndex": 64093, - "Kind": 3 - }, - { - "EndIndex": 64099, - "Kind": 3 - }, - { - "EndIndex": 64136, - "Kind": 3 - }, - { - "EndIndex": 64307, - "Kind": 3 - }, - { - "EndIndex": 64332, - "Kind": 3 - }, - { - "EndIndex": 64338, - "Kind": 3 - }, - { - "EndIndex": 64390, - "Kind": 3 - }, - { - "EndIndex": 64674, - "Kind": 3 - }, - { - "EndIndex": 64696, - "Kind": 3 - }, - { - "EndIndex": 64702, - "Kind": 3 - }, - { - "EndIndex": 64731, - "Kind": 3 - }, - { - "EndIndex": 64886, - "Kind": 3 - }, - { - "EndIndex": 64910, - "Kind": 3 - }, - { - "EndIndex": 64916, - "Kind": 3 - }, - { - "EndIndex": 64941, - "Kind": 3 - }, - { - "EndIndex": 65078, - "Kind": 3 - }, - { - "EndIndex": 65102, - "Kind": 3 - }, - { - "EndIndex": 65108, - "Kind": 3 - }, - { - "EndIndex": 65130, - "Kind": 3 - }, - { - "EndIndex": 65299, - "Kind": 3 - }, - { - "EndIndex": 65323, - "Kind": 3 - }, - { - "EndIndex": 65329, - "Kind": 3 - }, - { - "EndIndex": 65370, - "Kind": 3 - }, - { - "EndIndex": 65680, - "Kind": 3 - }, - { - "EndIndex": 65704, - "Kind": 3 - }, - { - "EndIndex": 65710, - "Kind": 3 - }, - { - "EndIndex": 65732, - "Kind": 3 - }, - { - "EndIndex": 65838, - "Kind": 3 - }, - { - "EndIndex": 65862, - "Kind": 3 - }, - { - "EndIndex": 65868, - "Kind": 3 - }, - { - "EndIndex": 65897, - "Kind": 3 - }, - { - "EndIndex": 66050, - "Kind": 3 - }, - { - "EndIndex": 66074, - "Kind": 3 - }, - { - "EndIndex": 66080, - "Kind": 3 - }, - { - "EndIndex": 66082, - "Kind": 3 - }, - { - "EndIndex": 66101, - "Kind": 3 - }, - { - "EndIndex": 66132, - "Kind": 3 - }, - { - "EndIndex": 66164, - "Kind": 3 - }, - { - "EndIndex": 66203, - "Kind": 3 - }, - { - "EndIndex": 66242, - "Kind": 3 - }, - { - "EndIndex": 66256, - "Kind": 3 - }, - { - "EndIndex": 66262, - "Kind": 3 - }, - { - "EndIndex": 66304, - "Kind": 3 - }, - { - "EndIndex": 66318, - "Kind": 3 - }, - { - "EndIndex": 66324, - "Kind": 3 - }, - { - "EndIndex": 66342, - "Kind": 3 - }, - { - "EndIndex": 66375, - "Kind": 3 - }, - { - "EndIndex": 66526, - "Kind": 3 - }, - { - "EndIndex": 66547, - "Kind": 3 - }, - { - "EndIndex": 66553, - "Kind": 3 - }, - { - "EndIndex": 66578, - "Kind": 3 - }, - { - "EndIndex": 66611, - "Kind": 3 - }, - { - "EndIndex": 66644, - "Kind": 3 - }, - { - "EndIndex": 66650, - "Kind": 3 - }, - { - "EndIndex": 66682, - "Kind": 3 - }, - { - "EndIndex": 66748, - "Kind": 3 - }, - { - "EndIndex": 66766, - "Kind": 3 - }, - { - "EndIndex": 66772, - "Kind": 3 - }, - { - "EndIndex": 66797, - "Kind": 3 - }, - { - "EndIndex": 66830, - "Kind": 3 - }, - { - "EndIndex": 66848, - "Kind": 3 - }, - { - "EndIndex": 66854, - "Kind": 3 - }, - { - "EndIndex": 66881, - "Kind": 3 - }, - { - "EndIndex": 66931, - "Kind": 3 - }, - { - "EndIndex": 66961, - "Kind": 3 - }, - { - "EndIndex": 66967, - "Kind": 3 - }, - { - "EndIndex": 67003, - "Kind": 3 - }, - { - "EndIndex": 67052, - "Kind": 3 - }, - { - "EndIndex": 67073, - "Kind": 3 - }, - { - "EndIndex": 67079, - "Kind": 3 - }, - { - "EndIndex": 67097, - "Kind": 3 - }, - { - "EndIndex": 67139, - "Kind": 3 - }, - { - "EndIndex": 67465, - "Kind": 3 - }, - { - "EndIndex": 67487, - "Kind": 3 - }, - { - "EndIndex": 67493, - "Kind": 3 - }, - { - "EndIndex": 67495, - "Kind": 3 - }, - { - "EndIndex": 67531, - "Kind": 3 - }, - { - "EndIndex": 67551, - "Kind": 3 - }, - { - "EndIndex": 67989, - "Kind": 3 - }, - { - "EndIndex": 68020, - "Kind": 3 - }, - { - "EndIndex": 68050, - "Kind": 3 - }, - { - "EndIndex": 68072, - "Kind": 3 - }, - { - "EndIndex": 68078, - "Kind": 3 - }, - { - "EndIndex": 68099, - "Kind": 3 - }, - { - "EndIndex": 68133, - "Kind": 3 - }, - { - "EndIndex": 68164, - "Kind": 3 - }, - { - "EndIndex": 68186, - "Kind": 3 - }, - { - "EndIndex": 68192, - "Kind": 3 - }, - { - "EndIndex": 68222, - "Kind": 3 - }, - { - "EndIndex": 68253, - "Kind": 3 - }, - { - "EndIndex": 68275, - "Kind": 3 - }, - { - "EndIndex": 68281, - "Kind": 3 - }, - { - "EndIndex": 68321, - "Kind": 3 - }, - { - "EndIndex": 68402, - "Kind": 3 - }, - { - "EndIndex": 68421, - "Kind": 3 - }, - { - "EndIndex": 68427, - "Kind": 3 - }, - { - "EndIndex": 68457, - "Kind": 3 - }, - { - "EndIndex": 68488, - "Kind": 3 - }, - { - "EndIndex": 68510, - "Kind": 3 - }, - { - "EndIndex": 68516, - "Kind": 3 - }, - { - "EndIndex": 68555, - "Kind": 3 - }, - { - "EndIndex": 68594, - "Kind": 3 - }, - { - "EndIndex": 68608, - "Kind": 3 - }, - { - "EndIndex": 68614, - "Kind": 3 - }, - { - "EndIndex": 68647, - "Kind": 3 - }, - { - "EndIndex": 68676, - "Kind": 3 - }, - { - "EndIndex": 68698, - "Kind": 3 - }, - { - "EndIndex": 68704, - "Kind": 3 - }, - { - "EndIndex": 68735, - "Kind": 3 - }, - { - "EndIndex": 68754, - "Kind": 3 - }, - { - "EndIndex": 68760, - "Kind": 3 - }, - { - "EndIndex": 68790, - "Kind": 3 - }, - { - "EndIndex": 68820, - "Kind": 3 - }, - { - "EndIndex": 68842, - "Kind": 3 - }, - { - "EndIndex": 68848, - "Kind": 3 - }, - { - "EndIndex": 68873, - "Kind": 3 - }, - { - "EndIndex": 68903, - "Kind": 3 - }, - { - "EndIndex": 68921, - "Kind": 3 - }, - { - "EndIndex": 68927, - "Kind": 3 - }, - { - "EndIndex": 68997, - "Kind": 3 - }, - { - "EndIndex": 69439, - "Kind": 3 - }, - { - "EndIndex": 69453, - "Kind": 3 - }, - { - "EndIndex": 69459, - "Kind": 3 - }, - { - "EndIndex": 69477, - "Kind": 3 - }, - { - "EndIndex": 69510, - "Kind": 3 - }, - { - "EndIndex": 69661, - "Kind": 3 - }, - { - "EndIndex": 69682, - "Kind": 3 - }, - { - "EndIndex": 69688, - "Kind": 3 - }, - { - "EndIndex": 69713, - "Kind": 3 - }, - { - "EndIndex": 69746, - "Kind": 3 - }, - { - "EndIndex": 69784, - "Kind": 3 - }, - { - "EndIndex": 69790, - "Kind": 3 - }, - { - "EndIndex": 69820, - "Kind": 3 - }, - { - "EndIndex": 69851, - "Kind": 3 - }, - { - "EndIndex": 69873, - "Kind": 3 - }, - { - "EndIndex": 69879, - "Kind": 3 - }, - { - "EndIndex": 69903, - "Kind": 3 - }, - { - "EndIndex": 69932, - "Kind": 3 - }, - { - "EndIndex": 69950, - "Kind": 3 - }, - { - "EndIndex": 69956, - "Kind": 3 - }, - { - "EndIndex": 69986, - "Kind": 3 - }, - { - "EndIndex": 70016, - "Kind": 3 - }, - { - "EndIndex": 70038, - "Kind": 3 - }, - { - "EndIndex": 70044, - "Kind": 3 - }, - { - "EndIndex": 70075, - "Kind": 3 - }, - { - "EndIndex": 70105, - "Kind": 3 - }, - { - "EndIndex": 70127, - "Kind": 3 - }, - { - "EndIndex": 70133, - "Kind": 3 - }, - { - "EndIndex": 70164, - "Kind": 3 - }, - { - "EndIndex": 70194, - "Kind": 3 - }, - { - "EndIndex": 70216, - "Kind": 3 - }, - { - "EndIndex": 70222, - "Kind": 3 - }, - { - "EndIndex": 70252, - "Kind": 3 - }, - { - "EndIndex": 70283, - "Kind": 3 - }, - { - "EndIndex": 70305, - "Kind": 3 - }, - { - "EndIndex": 70311, - "Kind": 3 - }, - { - "EndIndex": 70336, - "Kind": 3 - }, - { - "EndIndex": 70366, - "Kind": 3 - }, - { - "EndIndex": 70385, - "Kind": 3 - }, - { - "EndIndex": 70391, - "Kind": 3 - }, - { - "EndIndex": 70423, - "Kind": 3 - }, - { - "EndIndex": 70453, - "Kind": 3 - }, - { - "EndIndex": 70475, - "Kind": 3 - }, - { - "EndIndex": 70481, - "Kind": 3 - }, - { - "EndIndex": 70513, - "Kind": 3 - }, - { - "EndIndex": 70543, - "Kind": 3 - }, - { - "EndIndex": 70565, - "Kind": 3 - }, - { - "EndIndex": 70571, - "Kind": 3 - }, - { - "EndIndex": 70598, - "Kind": 3 - }, - { - "EndIndex": 70660, - "Kind": 3 - }, - { - "EndIndex": 70678, - "Kind": 3 - }, - { - "EndIndex": 70684, - "Kind": 3 - }, - { - "EndIndex": 70708, - "Kind": 3 - }, - { - "EndIndex": 70737, - "Kind": 3 - }, - { - "EndIndex": 70756, - "Kind": 3 - }, - { - "EndIndex": 70762, - "Kind": 3 - }, - { - "EndIndex": 70780, - "Kind": 3 - }, - { - "EndIndex": 70822, - "Kind": 3 - }, - { - "EndIndex": 71148, - "Kind": 3 - }, - { - "EndIndex": 71170, - "Kind": 3 - }, - { - "EndIndex": 71176, - "Kind": 3 - }, - { - "EndIndex": 71203, - "Kind": 3 - }, - { - "EndIndex": 71347, - "Kind": 3 - }, - { - "EndIndex": 71369, - "Kind": 3 - }, - { - "EndIndex": 71375, - "Kind": 3 - }, - { - "EndIndex": 71400, - "Kind": 3 - }, - { - "EndIndex": 71477, - "Kind": 3 - }, - { - "EndIndex": 71499, - "Kind": 3 - }, - { - "EndIndex": 71505, - "Kind": 3 - }, - { - "EndIndex": 71545, - "Kind": 3 - }, - { - "EndIndex": 71674, - "Kind": 3 - }, - { - "EndIndex": 71696, - "Kind": 3 - }, - { - "EndIndex": 71702, - "Kind": 3 - }, - { - "EndIndex": 71746, - "Kind": 3 - }, - { - "EndIndex": 71960, - "Kind": 3 - }, - { - "EndIndex": 71978, - "Kind": 3 - }, - { - "EndIndex": 71984, - "Kind": 3 - }, - { - "EndIndex": 72025, - "Kind": 3 - }, - { - "EndIndex": 72500, - "Kind": 3 - }, - { - "EndIndex": 72520, - "Kind": 3 - }, - { - "EndIndex": 72526, - "Kind": 3 - }, - { - "EndIndex": 72576, - "Kind": 3 - }, - { - "EndIndex": 72858, - "Kind": 3 - }, - { - "EndIndex": 72880, - "Kind": 3 - }, - { - "EndIndex": 72886, - "Kind": 3 - }, - { - "EndIndex": 72922, - "Kind": 3 - }, - { - "EndIndex": 73066, - "Kind": 3 - }, - { - "EndIndex": 73088, - "Kind": 3 - }, - { - "EndIndex": 73094, - "Kind": 3 - }, - { - "EndIndex": 73137, - "Kind": 3 - }, - { - "EndIndex": 73392, - "Kind": 3 - }, - { - "EndIndex": 73410, - "Kind": 3 - }, - { - "EndIndex": 73416, - "Kind": 3 - }, - { - "EndIndex": 73456, - "Kind": 3 - }, - { - "EndIndex": 73637, - "Kind": 3 - }, - { - "EndIndex": 73659, - "Kind": 3 - }, - { - "EndIndex": 73665, - "Kind": 3 - }, - { - "EndIndex": 73701, - "Kind": 3 - }, - { - "EndIndex": 73870, - "Kind": 3 - }, - { - "EndIndex": 73892, - "Kind": 3 - }, - { - "EndIndex": 73898, - "Kind": 3 - }, - { - "EndIndex": 73942, - "Kind": 3 - }, - { - "EndIndex": 74228, - "Kind": 3 - }, - { - "EndIndex": 74246, - "Kind": 3 - }, - { - "EndIndex": 74252, - "Kind": 3 - }, - { - "EndIndex": 74276, - "Kind": 3 - }, - { - "EndIndex": 74489, - "Kind": 3 - }, - { - "EndIndex": 74511, - "Kind": 3 - }, - { - "EndIndex": 74517, - "Kind": 3 - }, - { - "EndIndex": 74541, - "Kind": 3 - }, - { - "EndIndex": 74745, - "Kind": 3 - }, - { - "EndIndex": 74767, - "Kind": 3 - }, - { - "EndIndex": 74773, - "Kind": 3 - }, - { - "EndIndex": 74797, - "Kind": 3 - }, - { - "EndIndex": 74973, - "Kind": 3 - }, - { - "EndIndex": 74987, - "Kind": 3 - }, - { - "EndIndex": 74993, - "Kind": 3 - }, - { - "EndIndex": 75019, - "Kind": 3 - }, - { - "EndIndex": 75222, - "Kind": 3 - }, - { - "EndIndex": 75244, - "Kind": 3 - }, - { - "EndIndex": 75250, - "Kind": 3 - }, - { - "EndIndex": 75274, - "Kind": 3 - }, - { - "EndIndex": 75472, - "Kind": 3 - }, - { - "EndIndex": 75494, - "Kind": 3 - }, - { - "EndIndex": 75500, - "Kind": 3 - }, - { - "EndIndex": 75529, - "Kind": 3 - }, - { - "EndIndex": 75701, - "Kind": 3 - }, - { - "EndIndex": 75723, - "Kind": 3 - }, - { - "EndIndex": 75729, - "Kind": 3 - }, - { - "EndIndex": 75753, - "Kind": 3 - }, - { - "EndIndex": 75965, - "Kind": 3 - }, - { - "EndIndex": 75987, - "Kind": 3 - }, - { - "EndIndex": 75993, - "Kind": 3 - }, - { - "EndIndex": 76019, - "Kind": 3 - }, - { - "EndIndex": 76213, - "Kind": 3 - }, - { - "EndIndex": 76235, - "Kind": 3 - }, - { - "EndIndex": 76241, - "Kind": 3 - }, - { - "EndIndex": 76269, - "Kind": 3 - }, - { - "EndIndex": 76442, - "Kind": 3 - }, - { - "EndIndex": 76464, - "Kind": 3 - }, - { - "EndIndex": 76470, - "Kind": 3 - }, - { - "EndIndex": 76494, - "Kind": 3 - }, - { - "EndIndex": 76697, - "Kind": 3 - }, - { - "EndIndex": 76719, - "Kind": 3 - }, - { - "EndIndex": 76725, - "Kind": 3 - }, - { - "EndIndex": 76749, - "Kind": 3 - }, - { - "EndIndex": 76967, - "Kind": 3 - }, - { - "EndIndex": 76989, - "Kind": 3 - }, - { - "EndIndex": 76995, - "Kind": 3 - }, - { - "EndIndex": 77019, - "Kind": 3 - }, - { - "EndIndex": 77232, - "Kind": 3 - }, - { - "EndIndex": 77254, - "Kind": 3 - }, - { - "EndIndex": 77260, - "Kind": 3 - }, - { - "EndIndex": 77291, - "Kind": 3 - }, - { - "EndIndex": 77512, - "Kind": 3 - }, - { - "EndIndex": 77531, - "Kind": 3 - }, - { - "EndIndex": 77537, - "Kind": 3 - }, - { - "EndIndex": 77576, - "Kind": 3 - }, - { - "EndIndex": 77711, - "Kind": 3 - }, - { - "EndIndex": 77733, - "Kind": 3 - }, - { - "EndIndex": 77739, - "Kind": 3 - }, - { - "EndIndex": 77761, - "Kind": 3 - }, - { - "EndIndex": 77824, - "Kind": 3 - }, - { - "EndIndex": 77846, - "Kind": 3 - }, - { - "EndIndex": 77852, - "Kind": 3 - }, - { - "EndIndex": 77882, - "Kind": 3 - }, - { - "EndIndex": 78025, - "Kind": 3 - }, - { - "EndIndex": 78047, - "Kind": 3 - }, - { - "EndIndex": 78053, - "Kind": 3 - }, - { - "EndIndex": 78071, - "Kind": 3 - }, - { - "EndIndex": 78105, - "Kind": 3 - }, - { - "EndIndex": 78658, - "Kind": 3 - }, - { - "EndIndex": 78677, - "Kind": 3 - }, - { - "EndIndex": 78683, - "Kind": 3 - }, - { - "EndIndex": 78714, - "Kind": 3 - }, - { - "EndIndex": 79085, - "Kind": 3 - }, - { - "EndIndex": 79123, - "Kind": 3 - }, - { - "EndIndex": 79129, - "Kind": 3 - }, - { - "EndIndex": 79170, - "Kind": 3 - }, - { - "EndIndex": 79459, - "Kind": 3 - }, - { - "EndIndex": 79481, - "Kind": 3 - }, - { - "EndIndex": 79487, - "Kind": 3 - }, - { - "EndIndex": 79531, - "Kind": 3 - }, - { - "EndIndex": 79788, - "Kind": 3 - }, - { - "EndIndex": 79806, - "Kind": 3 - }, - { - "EndIndex": 79812, - "Kind": 3 - }, - { - "EndIndex": 79857, - "Kind": 3 - }, - { - "EndIndex": 80144, - "Kind": 3 - }, - { - "EndIndex": 80162, - "Kind": 3 - }, - { - "EndIndex": 80168, - "Kind": 3 - }, - { - "EndIndex": 80207, - "Kind": 3 - }, - { - "EndIndex": 80343, - "Kind": 3 - }, - { - "EndIndex": 80365, - "Kind": 3 - }, - { - "EndIndex": 80371, - "Kind": 3 - }, - { - "EndIndex": 80403, - "Kind": 3 - }, - { - "EndIndex": 80794, - "Kind": 3 - }, - { - "EndIndex": 80832, - "Kind": 3 - }, - { - "EndIndex": 80838, - "Kind": 3 - }, - { - "EndIndex": 80876, - "Kind": 3 - }, - { - "EndIndex": 81320, - "Kind": 3 - }, - { - "EndIndex": 81344, - "Kind": 3 - }, - { - "EndIndex": 81350, - "Kind": 3 - }, - { - "EndIndex": 81380, - "Kind": 3 - }, - { - "EndIndex": 81524, - "Kind": 3 - }, - { - "EndIndex": 81546, - "Kind": 3 - }, - { - "EndIndex": 81552, - "Kind": 3 - }, - { - "EndIndex": 81589, - "Kind": 3 - }, - { - "EndIndex": 81954, - "Kind": 3 - }, - { - "EndIndex": 81978, - "Kind": 3 - }, - { - "EndIndex": 81984, - "Kind": 3 - }, - { - "EndIndex": 82021, - "Kind": 3 - }, - { - "EndIndex": 82193, - "Kind": 3 - }, - { - "EndIndex": 82218, - "Kind": 3 - }, - { - "EndIndex": 82224, - "Kind": 3 - }, - { - "EndIndex": 82276, - "Kind": 3 - }, - { - "EndIndex": 82562, - "Kind": 3 - }, - { - "EndIndex": 82584, - "Kind": 3 - }, - { - "EndIndex": 82590, - "Kind": 3 - }, - { - "EndIndex": 82619, - "Kind": 3 - }, - { - "EndIndex": 82774, - "Kind": 3 - }, - { - "EndIndex": 82796, - "Kind": 3 - }, - { - "EndIndex": 82802, - "Kind": 3 - }, - { - "EndIndex": 82827, - "Kind": 3 - }, - { - "EndIndex": 82919, - "Kind": 3 - }, - { - "EndIndex": 82941, - "Kind": 3 - }, - { - "EndIndex": 82947, - "Kind": 3 - }, - { - "EndIndex": 82969, - "Kind": 3 - }, - { - "EndIndex": 83156, - "Kind": 3 - }, - { - "EndIndex": 83178, - "Kind": 3 - }, - { - "EndIndex": 83184, - "Kind": 3 - }, - { - "EndIndex": 83217, - "Kind": 3 - }, - { - "EndIndex": 83633, - "Kind": 3 - }, - { - "EndIndex": 83655, - "Kind": 3 - }, - { - "EndIndex": 83661, - "Kind": 3 - }, - { - "EndIndex": 83683, - "Kind": 3 - }, - { - "EndIndex": 83746, - "Kind": 3 - }, - { - "EndIndex": 83768, - "Kind": 3 - }, - { - "EndIndex": 83774, - "Kind": 3 - }, - { - "EndIndex": 83803, - "Kind": 3 - }, - { - "EndIndex": 83929, - "Kind": 3 - }, - { - "EndIndex": 83951, - "Kind": 3 - }, - { - "EndIndex": 83957, - "Kind": 3 - }, - { - "EndIndex": 83959, - "Kind": 3 - }, - { - "EndIndex": 83978, - "Kind": 3 - }, - { - "EndIndex": 84007, - "Kind": 3 - }, - { - "EndIndex": 84037, - "Kind": 3 - }, - { - "EndIndex": 84076, - "Kind": 3 - }, - { - "EndIndex": 84115, - "Kind": 3 - }, - { - "EndIndex": 84129, - "Kind": 3 - }, - { - "EndIndex": 84135, - "Kind": 3 - }, - { - "EndIndex": 84177, - "Kind": 3 - }, - { - "EndIndex": 84191, - "Kind": 3 - }, - { - "EndIndex": 84197, - "Kind": 3 - }, - { - "EndIndex": 84215, - "Kind": 3 - }, - { - "EndIndex": 84248, - "Kind": 3 - }, - { - "EndIndex": 84399, - "Kind": 3 - }, - { - "EndIndex": 84420, - "Kind": 3 - }, - { - "EndIndex": 84426, - "Kind": 3 - }, - { - "EndIndex": 84451, - "Kind": 3 - }, - { - "EndIndex": 84484, - "Kind": 3 - }, - { - "EndIndex": 84515, - "Kind": 3 - }, - { - "EndIndex": 84521, - "Kind": 3 - }, - { - "EndIndex": 84553, - "Kind": 3 - }, - { - "EndIndex": 84619, - "Kind": 3 - }, - { - "EndIndex": 84637, - "Kind": 3 - }, - { - "EndIndex": 84643, - "Kind": 3 - }, - { - "EndIndex": 84668, - "Kind": 3 - }, - { - "EndIndex": 84701, - "Kind": 3 - }, - { - "EndIndex": 84731, - "Kind": 3 - }, - { - "EndIndex": 84737, - "Kind": 3 - }, - { - "EndIndex": 84764, - "Kind": 3 - }, - { - "EndIndex": 84814, - "Kind": 3 - }, - { - "EndIndex": 84844, - "Kind": 3 - }, - { - "EndIndex": 84850, - "Kind": 3 - }, - { - "EndIndex": 84886, - "Kind": 3 - }, - { - "EndIndex": 84935, - "Kind": 3 - }, - { - "EndIndex": 84956, - "Kind": 3 - }, - { - "EndIndex": 84962, - "Kind": 3 - }, - { - "EndIndex": 84980, - "Kind": 3 - }, - { - "EndIndex": 85022, - "Kind": 3 - }, - { - "EndIndex": 85348, - "Kind": 3 - }, - { - "EndIndex": 85370, - "Kind": 3 - }, - { - "EndIndex": 85376, - "Kind": 3 - }, - { - "EndIndex": 85378, - "Kind": 3 - }, - { - "EndIndex": 85414, - "Kind": 3 - }, - { - "EndIndex": 85437, - "Kind": 3 - }, - { - "EndIndex": 85476, - "Kind": 3 - }, - { - "EndIndex": 85499, - "Kind": 3 - }, - { - "EndIndex": 85605, - "Kind": 3 - }, - { - "EndIndex": 85629, - "Kind": 3 - }, - { - "EndIndex": 85663, - "Kind": 3 - }, - { - "EndIndex": 85705, - "Kind": 3 - }, - { - "EndIndex": 85726, - "Kind": 3 - }, - { - "EndIndex": 85732, - "Kind": 3 - }, - { - "EndIndex": 85751, - "Kind": 3 - }, - { - "EndIndex": 85775, - "Kind": 3 - }, - { - "EndIndex": 85838, - "Kind": 3 - }, - { - "EndIndex": 85859, - "Kind": 3 - }, - { - "EndIndex": 85865, - "Kind": 3 - }, - { - "EndIndex": 85904, - "Kind": 3 - }, - { - "EndIndex": 85943, - "Kind": 3 - }, - { - "EndIndex": 85957, - "Kind": 3 - }, - { - "EndIndex": 85963, - "Kind": 3 - }, - { - "EndIndex": 86005, - "Kind": 3 - }, - { - "EndIndex": 86115, - "Kind": 3 - }, - { - "EndIndex": 86129, - "Kind": 3 - }, - { - "EndIndex": 86135, - "Kind": 3 - }, - { - "EndIndex": 86153, - "Kind": 3 - }, - { - "EndIndex": 86186, - "Kind": 3 - }, - { - "EndIndex": 86337, - "Kind": 3 - }, - { - "EndIndex": 86358, - "Kind": 3 - }, - { - "EndIndex": 86364, - "Kind": 3 - }, - { - "EndIndex": 86389, - "Kind": 3 - }, - { - "EndIndex": 86419, - "Kind": 3 - }, - { - "EndIndex": 86438, - "Kind": 3 - }, - { - "EndIndex": 86444, - "Kind": 3 - }, - { - "EndIndex": 86485, - "Kind": 3 - }, - { - "EndIndex": 86534, - "Kind": 3 - }, - { - "EndIndex": 86555, - "Kind": 3 - }, - { - "EndIndex": 86561, - "Kind": 3 - }, - { - "EndIndex": 86579, - "Kind": 3 - }, - { - "EndIndex": 86621, - "Kind": 3 - }, - { - "EndIndex": 86947, - "Kind": 3 - }, - { - "EndIndex": 86969, - "Kind": 3 - }, - { - "EndIndex": 86975, - "Kind": 3 - }, - { - "EndIndex": 86977, - "Kind": 3 - }, - { - "EndIndex": 86998, - "Kind": 3 - }, - { - "EndIndex": 87023, - "Kind": 3 - }, - { - "EndIndex": 87328, - "Kind": 3 - }, - { - "EndIndex": 87343, - "Kind": 3 - }, - { - "EndIndex": 87375, - "Kind": 3 - }, - { - "EndIndex": 87394, - "Kind": 3 - }, - { - "EndIndex": 87400, - "Kind": 3 - }, - { - "EndIndex": 87442, - "Kind": 3 - }, - { - "EndIndex": 87478, - "Kind": 3 - }, - { - "EndIndex": 87492, - "Kind": 3 - }, - { - "EndIndex": 87498, - "Kind": 3 - }, - { - "EndIndex": 87524, - "Kind": 3 - }, - { - "EndIndex": 87539, - "Kind": 3 - }, - { - "EndIndex": 87567, - "Kind": 3 - }, - { - "EndIndex": 87581, - "Kind": 3 - }, - { - "EndIndex": 87587, - "Kind": 3 - }, - { - "EndIndex": 87602, - "Kind": 3 - }, - { - "EndIndex": 87627, - "Kind": 3 - }, - { - "EndIndex": 87652, - "Kind": 3 - }, - { - "EndIndex": 87658, - "Kind": 3 - }, - { - "EndIndex": 87673, - "Kind": 3 - }, - { - "EndIndex": 87702, - "Kind": 3 - }, - { - "EndIndex": 87716, - "Kind": 3 - }, - { - "EndIndex": 87722, - "Kind": 3 - }, - { - "EndIndex": 87741, - "Kind": 3 - }, - { - "EndIndex": 87782, - "Kind": 3 - }, - { - "EndIndex": 87850, - "Kind": 3 - }, - { - "EndIndex": 87877, - "Kind": 3 - }, - { - "EndIndex": 87883, - "Kind": 3 - }, - { - "EndIndex": 87898, - "Kind": 3 - }, - { - "EndIndex": 87926, - "Kind": 3 - }, - { - "EndIndex": 87945, - "Kind": 3 - }, - { - "EndIndex": 87951, - "Kind": 3 - }, - { - "EndIndex": 87993, - "Kind": 3 - }, - { - "EndIndex": 88302, - "Kind": 3 - }, - { - "EndIndex": 88316, - "Kind": 3 - }, - { - "EndIndex": 88322, - "Kind": 3 - }, - { - "EndIndex": 88340, - "Kind": 3 - }, - { - "EndIndex": 88373, - "Kind": 3 - }, - { - "EndIndex": 88524, - "Kind": 3 - }, - { - "EndIndex": 88545, - "Kind": 3 - }, - { - "EndIndex": 88551, - "Kind": 3 - }, - { - "EndIndex": 88566, - "Kind": 3 - }, - { - "EndIndex": 88597, - "Kind": 3 - }, - { - "EndIndex": 88611, - "Kind": 3 - }, - { - "EndIndex": 88617, - "Kind": 3 - }, - { - "EndIndex": 88644, - "Kind": 3 - }, - { - "EndIndex": 88675, - "Kind": 3 - }, - { - "EndIndex": 88700, - "Kind": 3 - }, - { - "EndIndex": 88730, - "Kind": 3 - }, - { - "EndIndex": 88749, - "Kind": 3 - }, - { - "EndIndex": 88755, - "Kind": 3 - }, - { - "EndIndex": 88773, - "Kind": 3 - }, - { - "EndIndex": 88815, - "Kind": 3 - }, - { - "EndIndex": 89141, - "Kind": 3 - }, - { - "EndIndex": 89163, - "Kind": 3 - }, - { - "EndIndex": 89169, - "Kind": 3 - }, - { - "EndIndex": 89171, - "Kind": 3 - }, - { - "EndIndex": 89196, - "Kind": 3 - }, - { - "EndIndex": 89231, - "Kind": 3 - }, - { - "EndIndex": 89273, - "Kind": 3 - }, - { - "EndIndex": 89309, - "Kind": 3 - }, - { - "EndIndex": 89323, - "Kind": 3 - }, - { - "EndIndex": 89329, - "Kind": 3 - }, - { - "EndIndex": 89365, - "Kind": 3 - }, - { - "EndIndex": 89406, - "Kind": 3 - }, - { - "EndIndex": 89474, - "Kind": 3 - }, - { - "EndIndex": 89511, - "Kind": 3 - }, - { - "EndIndex": 89517, - "Kind": 3 - }, - { - "EndIndex": 89556, - "Kind": 3 - }, - { - "EndIndex": 89595, - "Kind": 3 - }, - { - "EndIndex": 89609, - "Kind": 3 - }, - { - "EndIndex": 89615, - "Kind": 3 - }, - { - "EndIndex": 89633, - "Kind": 3 - }, - { - "EndIndex": 89666, - "Kind": 3 - }, - { - "EndIndex": 89817, - "Kind": 3 - }, - { - "EndIndex": 89838, - "Kind": 3 - }, - { - "EndIndex": 89844, - "Kind": 3 - }, - { - "EndIndex": 89881, - "Kind": 3 - }, - { - "EndIndex": 89896, - "Kind": 3 - }, - { - "EndIndex": 89925, - "Kind": 3 - }, - { - "EndIndex": 89939, - "Kind": 3 - }, - { - "EndIndex": 89945, - "Kind": 3 - }, - { - "EndIndex": 89986, - "Kind": 3 - }, - { - "EndIndex": 90013, - "Kind": 3 - }, - { - "EndIndex": 90043, - "Kind": 3 - }, - { - "EndIndex": 90049, - "Kind": 3 - }, - { - "EndIndex": 90074, - "Kind": 3 - }, - { - "EndIndex": 90104, - "Kind": 3 - }, - { - "EndIndex": 90123, - "Kind": 3 - }, - { - "EndIndex": 90129, - "Kind": 3 - }, - { - "EndIndex": 90147, - "Kind": 3 - }, - { - "EndIndex": 90189, - "Kind": 3 - }, - { - "EndIndex": 90515, - "Kind": 3 - }, - { - "EndIndex": 90537, - "Kind": 3 - }, - { - "EndIndex": 90543, - "Kind": 3 - }, - { - "EndIndex": 90574, - "Kind": 3 - }, - { - "EndIndex": 90576, - "Kind": 3 - }, - { - "EndIndex": 90626, - "Kind": 3 - }, - { - "EndIndex": 90669, - "Kind": 3 - }, - { - "EndIndex": 90711, - "Kind": 3 - }, - { - "EndIndex": 90747, - "Kind": 3 - }, - { - "EndIndex": 90761, - "Kind": 3 - }, - { - "EndIndex": 90767, - "Kind": 3 - }, - { - "EndIndex": 90811, - "Kind": 3 - }, - { - "EndIndex": 90841, - "Kind": 3 - }, - { - "EndIndex": 90872, - "Kind": 3 - }, - { - "EndIndex": 90894, - "Kind": 3 - }, - { - "EndIndex": 90900, - "Kind": 3 - }, - { - "EndIndex": 90930, - "Kind": 3 - }, - { - "EndIndex": 90961, - "Kind": 3 - }, - { - "EndIndex": 90983, - "Kind": 3 - }, - { - "EndIndex": 90989, - "Kind": 3 - }, - { - "EndIndex": 91028, - "Kind": 3 - }, - { - "EndIndex": 91067, - "Kind": 3 - }, - { - "EndIndex": 91081, - "Kind": 3 - }, - { - "EndIndex": 91087, - "Kind": 3 - }, - { - "EndIndex": 91117, - "Kind": 3 - }, - { - "EndIndex": 91147, - "Kind": 3 - }, - { - "EndIndex": 91169, - "Kind": 3 - }, - { - "EndIndex": 91175, - "Kind": 3 - }, - { - "EndIndex": 91200, - "Kind": 3 - }, - { - "EndIndex": 91230, - "Kind": 3 - }, - { - "EndIndex": 91248, - "Kind": 3 - }, - { - "EndIndex": 91254, - "Kind": 3 - }, - { - "EndIndex": 91272, - "Kind": 3 - }, - { - "EndIndex": 91305, - "Kind": 3 - }, - { - "EndIndex": 91456, - "Kind": 3 - }, - { - "EndIndex": 91477, - "Kind": 3 - }, - { - "EndIndex": 91483, - "Kind": 3 - }, - { - "EndIndex": 91513, - "Kind": 3 - }, - { - "EndIndex": 91544, - "Kind": 3 - }, - { - "EndIndex": 91566, - "Kind": 3 - }, - { - "EndIndex": 91572, - "Kind": 3 - }, - { - "EndIndex": 91602, - "Kind": 3 - }, - { - "EndIndex": 91632, - "Kind": 3 - }, - { - "EndIndex": 91654, - "Kind": 3 - }, - { - "EndIndex": 91660, - "Kind": 3 - }, - { - "EndIndex": 91705, - "Kind": 3 - }, - { - "EndIndex": 91735, - "Kind": 3 - }, - { - "EndIndex": 91766, - "Kind": 3 - }, - { - "EndIndex": 91788, - "Kind": 3 - }, - { - "EndIndex": 91794, - "Kind": 3 - }, - { - "EndIndex": 91843, - "Kind": 3 - }, - { - "EndIndex": 91870, - "Kind": 3 - }, - { - "EndIndex": 91900, - "Kind": 3 - }, - { - "EndIndex": 91906, - "Kind": 3 - }, - { - "EndIndex": 91931, - "Kind": 3 - }, - { - "EndIndex": 91961, - "Kind": 3 - }, - { - "EndIndex": 91980, - "Kind": 3 - }, - { - "EndIndex": 91986, - "Kind": 3 - }, - { - "EndIndex": 92001, - "Kind": 3 - }, - { - "EndIndex": 92026, - "Kind": 3 - }, - { - "EndIndex": 92040, - "Kind": 3 - }, - { - "EndIndex": 92046, - "Kind": 3 - }, - { - "EndIndex": 92064, - "Kind": 3 - }, - { - "EndIndex": 92106, - "Kind": 3 - }, - { - "EndIndex": 92432, - "Kind": 3 - }, - { - "EndIndex": 92454, - "Kind": 3 - }, - { - "EndIndex": 92460, - "Kind": 3 - }, - { - "EndIndex": 92491, - "Kind": 3 - }, - { - "EndIndex": 92493, - "Kind": 3 - }, - { - "EndIndex": 92543, - "Kind": 3 - }, - { - "EndIndex": 92569, - "Kind": 3 - }, - { - "EndIndex": 92596, - "Kind": 3 - }, - { - "EndIndex": 92620, - "Kind": 3 - }, - { - "EndIndex": 92641, - "Kind": 3 - }, - { - "EndIndex": 92647, - "Kind": 3 - }, - { - "EndIndex": 92686, - "Kind": 3 - }, - { - "EndIndex": 92725, - "Kind": 3 - }, - { - "EndIndex": 92739, - "Kind": 3 - }, - { - "EndIndex": 92745, - "Kind": 3 - }, - { - "EndIndex": 92787, - "Kind": 3 - }, - { - "EndIndex": 92801, - "Kind": 3 - }, - { - "EndIndex": 92807, - "Kind": 3 - }, - { - "EndIndex": 92825, - "Kind": 3 - }, - { - "EndIndex": 92858, - "Kind": 3 - }, - { - "EndIndex": 93009, - "Kind": 3 - }, - { - "EndIndex": 93030, - "Kind": 3 - }, - { - "EndIndex": 93036, - "Kind": 3 - }, - { - "EndIndex": 93061, - "Kind": 3 - }, - { - "EndIndex": 93094, - "Kind": 3 - }, - { - "EndIndex": 93122, - "Kind": 3 - }, - { - "EndIndex": 93128, - "Kind": 3 - }, - { - "EndIndex": 93156, - "Kind": 3 - }, - { - "EndIndex": 93181, - "Kind": 3 - }, - { - "EndIndex": 93214, - "Kind": 3 - }, - { - "EndIndex": 93228, - "Kind": 3 - }, - { - "EndIndex": 93234, - "Kind": 3 - }, - { - "EndIndex": 93266, - "Kind": 3 - }, - { - "EndIndex": 93291, - "Kind": 3 - }, - { - "EndIndex": 93321, - "Kind": 3 - }, - { - "EndIndex": 93340, - "Kind": 3 - }, - { - "EndIndex": 93346, - "Kind": 3 - }, - { - "EndIndex": 93364, - "Kind": 3 - }, - { - "EndIndex": 93406, - "Kind": 3 - }, - { - "EndIndex": 93732, - "Kind": 3 - }, - { - "EndIndex": 93754, - "Kind": 3 - }, - { - "EndIndex": 93760, - "Kind": 3 - }, - { - "EndIndex": 93782, - "Kind": 3 - }, - { - "EndIndex": 93842, - "Kind": 3 - }, - { - "EndIndex": 93863, - "Kind": 3 - }, - { - "EndIndex": 93869, - "Kind": 3 - }, - { - "EndIndex": 93884, - "Kind": 3 - }, - { - "EndIndex": 93908, - "Kind": 3 - }, - { - "EndIndex": 93922, - "Kind": 3 - }, - { - "EndIndex": 93928, - "Kind": 3 - }, - { - "EndIndex": 93943, - "Kind": 3 - }, - { - "EndIndex": 93968, - "Kind": 3 - }, - { - "EndIndex": 93982, - "Kind": 3 - }, - { - "EndIndex": 93988, - "Kind": 3 - }, - { - "EndIndex": 94003, - "Kind": 3 - }, - { - "EndIndex": 94030, - "Kind": 3 - }, - { - "EndIndex": 94044, - "Kind": 3 - }, - { - "EndIndex": 94050, - "Kind": 3 - }, - { - "EndIndex": 94065, - "Kind": 3 - }, - { - "EndIndex": 94094, - "Kind": 3 - }, - { - "EndIndex": 94150, - "Kind": 3 - }, - { - "EndIndex": 94164, - "Kind": 3 - }, - { - "EndIndex": 94170, - "Kind": 3 - }, - { - "EndIndex": 94198, - "Kind": 3 - }, - { - "EndIndex": 94300, - "Kind": 3 - }, - { - "EndIndex": 94332, - "Kind": 3 - }, - { - "EndIndex": 94338, - "Kind": 3 - }, - { - "EndIndex": 94394, - "Kind": 3 - }, - { - "EndIndex": 94511, - "Kind": 3 - }, - { - "EndIndex": 94532, - "Kind": 3 - }, - { - "EndIndex": 94538, - "Kind": 3 - }, - { - "EndIndex": 94540, - "Kind": 3 - }, - { - "EndIndex": 94567, - "Kind": 3 - }, - { - "EndIndex": 94592, - "Kind": 3 - }, - { - "EndIndex": 95387, - "Kind": 3 - }, - { - "EndIndex": 95413, - "Kind": 3 - }, - { - "EndIndex": 95450, - "Kind": 3 - }, - { - "EndIndex": 95494, - "Kind": 3 - }, - { - "EndIndex": 95515, - "Kind": 3 - }, - { - "EndIndex": 95521, - "Kind": 3 - }, - { - "EndIndex": 95562, - "Kind": 3 - }, - { - "EndIndex": 95630, - "Kind": 3 - }, - { - "EndIndex": 95657, - "Kind": 3 - }, - { - "EndIndex": 95663, - "Kind": 3 - }, - { - "EndIndex": 95702, - "Kind": 3 - }, - { - "EndIndex": 95741, - "Kind": 3 - }, - { - "EndIndex": 95755, - "Kind": 3 - }, - { - "EndIndex": 95761, - "Kind": 3 - }, - { - "EndIndex": 95803, - "Kind": 3 - }, - { - "EndIndex": 96602, - "Kind": 3 - }, - { - "EndIndex": 96616, - "Kind": 3 - }, - { - "EndIndex": 96622, - "Kind": 3 - }, - { - "EndIndex": 96640, - "Kind": 3 - }, - { - "EndIndex": 96673, - "Kind": 3 - }, - { - "EndIndex": 96824, - "Kind": 3 - }, - { - "EndIndex": 96845, - "Kind": 3 - }, - { - "EndIndex": 96851, - "Kind": 3 - }, - { - "EndIndex": 96866, - "Kind": 3 - }, - { - "EndIndex": 96903, - "Kind": 3 - }, - { - "EndIndex": 96917, - "Kind": 3 - }, - { - "EndIndex": 96923, - "Kind": 3 - }, - { - "EndIndex": 96964, - "Kind": 3 - }, - { - "EndIndex": 97014, - "Kind": 3 - }, - { - "EndIndex": 97035, - "Kind": 3 - }, - { - "EndIndex": 97041, - "Kind": 3 - }, - { - "EndIndex": 97059, - "Kind": 3 - }, - { - "EndIndex": 97101, - "Kind": 3 - }, - { - "EndIndex": 97427, - "Kind": 3 - }, - { - "EndIndex": 97449, - "Kind": 3 - }, - { - "EndIndex": 97455, - "Kind": 3 - }, - { - "EndIndex": 97485, - "Kind": 3 - }, - { - "EndIndex": 97544, - "Kind": 3 - }, - { - "EndIndex": 97565, - "Kind": 3 - }, - { - "EndIndex": 97571, - "Kind": 3 - }, - { - "EndIndex": 97586, - "Kind": 3 - }, - { - "EndIndex": 97607, - "Kind": 3 - }, - { - "EndIndex": 97621, - "Kind": 3 - }, - { - "EndIndex": 97627, - "Kind": 3 - }, - { - "EndIndex": 97642, - "Kind": 3 - }, - { - "EndIndex": 97663, - "Kind": 3 - }, - { - "EndIndex": 97677, - "Kind": 3 - }, - { - "EndIndex": 97683, - "Kind": 3 - }, - { - "EndIndex": 97698, - "Kind": 3 - }, - { - "EndIndex": 97719, - "Kind": 3 - }, - { - "EndIndex": 97733, - "Kind": 3 - }, - { - "EndIndex": 97739, - "Kind": 3 - }, - { - "EndIndex": 97768, - "Kind": 3 - }, - { - "EndIndex": 97826, - "Kind": 3 - }, - { - "EndIndex": 97847, - "Kind": 3 - }, - { - "EndIndex": 97853, - "Kind": 3 - }, - { - "EndIndex": 97882, - "Kind": 3 - }, - { - "EndIndex": 97940, - "Kind": 3 - }, - { - "EndIndex": 97961, - "Kind": 3 - }, - { - "EndIndex": 97967, - "Kind": 3 - }, - { - "EndIndex": 97969, - "Kind": 3 - }, - { - "EndIndex": 97994, - "Kind": 3 - }, - { - "EndIndex": 98022, - "Kind": 3 - }, - { - "EndIndex": 98718, - "Kind": 3 - }, - { - "EndIndex": 98747, - "Kind": 3 - }, - { - "EndIndex": 98766, - "Kind": 3 - }, - { - "EndIndex": 98781, - "Kind": 3 - }, - { - "EndIndex": 98806, - "Kind": 3 - }, - { - "EndIndex": 98820, - "Kind": 3 - }, - { - "EndIndex": 98826, - "Kind": 3 - }, - { - "EndIndex": 98867, - "Kind": 3 - }, - { - "EndIndex": 98935, - "Kind": 3 - }, - { - "EndIndex": 98965, - "Kind": 3 - }, - { - "EndIndex": 98971, - "Kind": 3 - }, - { - "EndIndex": 99006, - "Kind": 3 - }, - { - "EndIndex": 99706, - "Kind": 3 - }, - { - "EndIndex": 99720, - "Kind": 3 - }, - { - "EndIndex": 99726, - "Kind": 3 - }, - { - "EndIndex": 99744, - "Kind": 3 - }, - { - "EndIndex": 99777, - "Kind": 3 - }, - { - "EndIndex": 99928, - "Kind": 3 - }, - { - "EndIndex": 99949, - "Kind": 3 - }, - { - "EndIndex": 99955, - "Kind": 3 - }, - { - "EndIndex": 99970, - "Kind": 3 - }, - { - "EndIndex": 100007, - "Kind": 3 - }, - { - "EndIndex": 100021, - "Kind": 3 - }, - { - "EndIndex": 100027, - "Kind": 3 - }, - { - "EndIndex": 100045, - "Kind": 3 - }, - { - "EndIndex": 100087, - "Kind": 3 - }, - { - "EndIndex": 100413, - "Kind": 3 - }, - { - "EndIndex": 100435, - "Kind": 3 - }, - { - "EndIndex": 100441, - "Kind": 3 - }, - { - "EndIndex": 100443, - "Kind": 3 - }, - { - "EndIndex": 100474, - "Kind": 3 - }, - { - "EndIndex": 100503, - "Kind": 3 - }, - { - "EndIndex": 101055, - "Kind": 3 - }, - { - "EndIndex": 101085, - "Kind": 3 - }, - { - "EndIndex": 101104, - "Kind": 3 - }, - { - "EndIndex": 101119, - "Kind": 3 - }, - { - "EndIndex": 101144, - "Kind": 3 - }, - { - "EndIndex": 101158, - "Kind": 3 - }, - { - "EndIndex": 101164, - "Kind": 3 - }, - { - "EndIndex": 101205, - "Kind": 3 - }, - { - "EndIndex": 101273, - "Kind": 3 - }, - { - "EndIndex": 101304, - "Kind": 3 - }, - { - "EndIndex": 101310, - "Kind": 3 - }, - { - "EndIndex": 101345, - "Kind": 3 - }, - { - "EndIndex": 101901, - "Kind": 3 - }, - { - "EndIndex": 101915, - "Kind": 3 - }, - { - "EndIndex": 101921, - "Kind": 3 - }, - { - "EndIndex": 101939, - "Kind": 3 - }, - { - "EndIndex": 101972, - "Kind": 3 - }, - { - "EndIndex": 102123, - "Kind": 3 - }, - { - "EndIndex": 102144, - "Kind": 3 - }, - { - "EndIndex": 102150, - "Kind": 3 - }, - { - "EndIndex": 102165, - "Kind": 3 - }, - { - "EndIndex": 102202, - "Kind": 3 - }, - { - "EndIndex": 102216, - "Kind": 3 - }, - { - "EndIndex": 102222, - "Kind": 3 - }, - { - "EndIndex": 102240, - "Kind": 3 - }, - { - "EndIndex": 102282, - "Kind": 3 - }, - { - "EndIndex": 102608, - "Kind": 3 - }, - { - "EndIndex": 102630, - "Kind": 3 - }, - { - "EndIndex": 102636, - "Kind": 3 - }, - { - "EndIndex": 102638, - "Kind": 3 - }, - { - "EndIndex": 102671, - "Kind": 3 - }, - { - "EndIndex": 102696, - "Kind": 3 - }, - { - "EndIndex": 102722, - "Kind": 3 - }, - { - "EndIndex": 102761, - "Kind": 3 - }, - { - "EndIndex": 102800, - "Kind": 3 - }, - { - "EndIndex": 102814, - "Kind": 3 - }, - { - "EndIndex": 102820, - "Kind": 3 - }, - { - "EndIndex": 102862, - "Kind": 3 - }, - { - "EndIndex": 102876, - "Kind": 3 - }, - { - "EndIndex": 102882, - "Kind": 3 - }, - { - "EndIndex": 102900, - "Kind": 3 - }, - { - "EndIndex": 102933, - "Kind": 3 - }, - { - "EndIndex": 103084, - "Kind": 3 - }, - { - "EndIndex": 103105, - "Kind": 3 - }, - { - "EndIndex": 103111, - "Kind": 3 - }, - { - "EndIndex": 103138, - "Kind": 3 - }, - { - "EndIndex": 103168, - "Kind": 3 - }, - { - "EndIndex": 103174, - "Kind": 3 - }, - { - "EndIndex": 103199, - "Kind": 3 - }, - { - "EndIndex": 103229, - "Kind": 3 - }, - { - "EndIndex": 103248, - "Kind": 3 - }, - { - "EndIndex": 103254, - "Kind": 3 - }, - { - "EndIndex": 103272, - "Kind": 3 - }, - { - "EndIndex": 103314, - "Kind": 3 - }, - { - "EndIndex": 103640, - "Kind": 3 - }, - { - "EndIndex": 103662, - "Kind": 3 - }, - { - "EndIndex": 103668, - "Kind": 3 - }, - { - "EndIndex": 103670, - "Kind": 3 - }, - { - "EndIndex": 103695, - "Kind": 3 - }, - { - "EndIndex": 103726, - "Kind": 3 - }, - { - "EndIndex": 103758, - "Kind": 3 - }, - { - "EndIndex": 103797, - "Kind": 3 - }, - { - "EndIndex": 103836, - "Kind": 3 - }, - { - "EndIndex": 103850, - "Kind": 3 - }, - { - "EndIndex": 103856, - "Kind": 3 - }, - { - "EndIndex": 103898, - "Kind": 3 - }, - { - "EndIndex": 103912, - "Kind": 3 - }, - { - "EndIndex": 103918, - "Kind": 3 - }, - { - "EndIndex": 103936, - "Kind": 3 - }, - { - "EndIndex": 103969, - "Kind": 3 - }, - { - "EndIndex": 104120, - "Kind": 3 - }, - { - "EndIndex": 104141, - "Kind": 3 - }, - { - "EndIndex": 104147, - "Kind": 3 - }, - { - "EndIndex": 104172, - "Kind": 3 - }, - { - "EndIndex": 104205, - "Kind": 3 - }, - { - "EndIndex": 104238, - "Kind": 3 - }, - { - "EndIndex": 104244, - "Kind": 3 - }, - { - "EndIndex": 104276, - "Kind": 3 - }, - { - "EndIndex": 104342, - "Kind": 3 - }, - { - "EndIndex": 104360, - "Kind": 3 - }, - { - "EndIndex": 104366, - "Kind": 3 - }, - { - "EndIndex": 104391, - "Kind": 3 - }, - { - "EndIndex": 104424, - "Kind": 3 - }, - { - "EndIndex": 104438, - "Kind": 3 - }, - { - "EndIndex": 104444, - "Kind": 3 - }, - { - "EndIndex": 104471, - "Kind": 3 - }, - { - "EndIndex": 104521, - "Kind": 3 - }, - { - "EndIndex": 104551, - "Kind": 3 - }, - { - "EndIndex": 104557, - "Kind": 3 - }, - { - "EndIndex": 104593, - "Kind": 3 - }, - { - "EndIndex": 104642, - "Kind": 3 - }, - { - "EndIndex": 104663, - "Kind": 3 - }, - { - "EndIndex": 104669, - "Kind": 3 - }, - { - "EndIndex": 104687, - "Kind": 3 - }, - { - "EndIndex": 104729, - "Kind": 3 - }, - { - "EndIndex": 105055, - "Kind": 3 - }, - { - "EndIndex": 105077, - "Kind": 3 - }, - { - "EndIndex": 105083, - "Kind": 3 - }, - { - "EndIndex": 105085, - "Kind": 3 - }, - { - "EndIndex": 105121, - "Kind": 3 - }, - { - "EndIndex": 105151, - "Kind": 3 - }, - { - "EndIndex": 105182, - "Kind": 3 - }, - { - "EndIndex": 105221, - "Kind": 3 - }, - { - "EndIndex": 105260, - "Kind": 3 - }, - { - "EndIndex": 105274, - "Kind": 3 - }, - { - "EndIndex": 105280, - "Kind": 3 - }, - { - "EndIndex": 105322, - "Kind": 3 - }, - { - "EndIndex": 105336, - "Kind": 3 - }, - { - "EndIndex": 105342, - "Kind": 3 - }, - { - "EndIndex": 105360, - "Kind": 3 - }, - { - "EndIndex": 105393, - "Kind": 3 - }, - { - "EndIndex": 105544, - "Kind": 3 - }, - { - "EndIndex": 105565, - "Kind": 3 - }, - { - "EndIndex": 105571, - "Kind": 3 - }, - { - "EndIndex": 105596, - "Kind": 3 - }, - { - "EndIndex": 105629, - "Kind": 3 - }, - { - "EndIndex": 105661, - "Kind": 3 - }, - { - "EndIndex": 105667, - "Kind": 3 - }, - { - "EndIndex": 105699, - "Kind": 3 - }, - { - "EndIndex": 105765, - "Kind": 3 - }, - { - "EndIndex": 105783, - "Kind": 3 - }, - { - "EndIndex": 105789, - "Kind": 3 - }, - { - "EndIndex": 105814, - "Kind": 3 - }, - { - "EndIndex": 105847, - "Kind": 3 - }, - { - "EndIndex": 105861, - "Kind": 3 - }, - { - "EndIndex": 105867, - "Kind": 3 - }, - { - "EndIndex": 105894, - "Kind": 3 - }, - { - "EndIndex": 105944, - "Kind": 3 - }, - { - "EndIndex": 105974, - "Kind": 3 - }, - { - "EndIndex": 105980, - "Kind": 3 - }, - { - "EndIndex": 106016, - "Kind": 3 - }, - { - "EndIndex": 106065, - "Kind": 3 - }, - { - "EndIndex": 106086, - "Kind": 3 - }, - { - "EndIndex": 106092, - "Kind": 3 - }, - { - "EndIndex": 106110, - "Kind": 3 - }, - { - "EndIndex": 106152, - "Kind": 3 - }, - { - "EndIndex": 106478, - "Kind": 3 - }, - { - "EndIndex": 106500, - "Kind": 3 - }, - { - "EndIndex": 106506, - "Kind": 3 - }, - { - "EndIndex": 106508, - "Kind": 3 - }, - { - "EndIndex": 106542, - "Kind": 3 - }, - { - "EndIndex": 106568, - "Kind": 3 - }, - { - "EndIndex": 106599, - "Kind": 3 - }, - { - "EndIndex": 106629, - "Kind": 3 - }, - { - "EndIndex": 106657, - "Kind": 3 - }, - { - "EndIndex": 106663, - "Kind": 3 - }, - { - "EndIndex": 106690, - "Kind": 3 - }, - { - "EndIndex": 106724, - "Kind": 3 - }, - { - "EndIndex": 106755, - "Kind": 3 - }, - { - "EndIndex": 106777, - "Kind": 3 - }, - { - "EndIndex": 106783, - "Kind": 3 - }, - { - "EndIndex": 106813, - "Kind": 3 - }, - { - "EndIndex": 106844, - "Kind": 3 - }, - { - "EndIndex": 106866, - "Kind": 3 - }, - { - "EndIndex": 106872, - "Kind": 3 - }, - { - "EndIndex": 106902, - "Kind": 3 - }, - { - "EndIndex": 106933, - "Kind": 3 - }, - { - "EndIndex": 106955, - "Kind": 3 - }, - { - "EndIndex": 106961, - "Kind": 3 - }, - { - "EndIndex": 107000, - "Kind": 3 - }, - { - "EndIndex": 107039, - "Kind": 3 - }, - { - "EndIndex": 107053, - "Kind": 3 - }, - { - "EndIndex": 107059, - "Kind": 3 - }, - { - "EndIndex": 107089, - "Kind": 3 - }, - { - "EndIndex": 107119, - "Kind": 3 - }, - { - "EndIndex": 107141, - "Kind": 3 - }, - { - "EndIndex": 107147, - "Kind": 3 - }, - { - "EndIndex": 107168, - "Kind": 3 - }, - { - "EndIndex": 107210, - "Kind": 3 - }, - { - "EndIndex": 107224, - "Kind": 3 - }, - { - "EndIndex": 107230, - "Kind": 3 - }, - { - "EndIndex": 107248, - "Kind": 3 - }, - { - "EndIndex": 107281, - "Kind": 3 - }, - { - "EndIndex": 107432, - "Kind": 3 - }, - { - "EndIndex": 107453, - "Kind": 3 - }, - { - "EndIndex": 107459, - "Kind": 3 - }, - { - "EndIndex": 107484, - "Kind": 3 - }, - { - "EndIndex": 107517, - "Kind": 3 - }, - { - "EndIndex": 107545, - "Kind": 3 - }, - { - "EndIndex": 107551, - "Kind": 3 - }, - { - "EndIndex": 107581, - "Kind": 3 - }, - { - "EndIndex": 107612, - "Kind": 3 - }, - { - "EndIndex": 107634, - "Kind": 3 - }, - { - "EndIndex": 107640, - "Kind": 3 - }, - { - "EndIndex": 107664, - "Kind": 3 - }, - { - "EndIndex": 107693, - "Kind": 3 - }, - { - "EndIndex": 107711, - "Kind": 3 - }, - { - "EndIndex": 107717, - "Kind": 3 - }, - { - "EndIndex": 107747, - "Kind": 3 - }, - { - "EndIndex": 107777, - "Kind": 3 - }, - { - "EndIndex": 107799, - "Kind": 3 - }, - { - "EndIndex": 107805, - "Kind": 3 - }, - { - "EndIndex": 107835, - "Kind": 3 - }, - { - "EndIndex": 107866, - "Kind": 3 - }, - { - "EndIndex": 107888, - "Kind": 3 - }, - { - "EndIndex": 107894, - "Kind": 3 - }, - { - "EndIndex": 107924, - "Kind": 3 - }, - { - "EndIndex": 107954, - "Kind": 3 - }, - { - "EndIndex": 107982, - "Kind": 3 - }, - { - "EndIndex": 107988, - "Kind": 3 - }, - { - "EndIndex": 108020, - "Kind": 3 - }, - { - "EndIndex": 108050, - "Kind": 3 - }, - { - "EndIndex": 108078, - "Kind": 3 - }, - { - "EndIndex": 108084, - "Kind": 3 - }, - { - "EndIndex": 108109, - "Kind": 3 - }, - { - "EndIndex": 108139, - "Kind": 3 - }, - { - "EndIndex": 108158, - "Kind": 3 - }, - { - "EndIndex": 108164, - "Kind": 3 - }, - { - "EndIndex": 108195, - "Kind": 3 - }, - { - "EndIndex": 108225, - "Kind": 3 - }, - { - "EndIndex": 108253, - "Kind": 3 - }, - { - "EndIndex": 108259, - "Kind": 3 - }, - { - "EndIndex": 108291, - "Kind": 3 - }, - { - "EndIndex": 108321, - "Kind": 3 - }, - { - "EndIndex": 108349, - "Kind": 3 - }, - { - "EndIndex": 108355, - "Kind": 3 - }, - { - "EndIndex": 108387, - "Kind": 3 - }, - { - "EndIndex": 108417, - "Kind": 3 - }, - { - "EndIndex": 108445, - "Kind": 3 - }, - { - "EndIndex": 108451, - "Kind": 3 - }, - { - "EndIndex": 108482, - "Kind": 3 - }, - { - "EndIndex": 108512, - "Kind": 3 - }, - { - "EndIndex": 108540, - "Kind": 3 - }, - { - "EndIndex": 108546, - "Kind": 3 - }, - { - "EndIndex": 108564, - "Kind": 3 - }, - { - "EndIndex": 108606, - "Kind": 3 - }, - { - "EndIndex": 108932, - "Kind": 3 - }, - { - "EndIndex": 108954, - "Kind": 3 - }, - { - "EndIndex": 108960, - "Kind": 3 - }, - { - "EndIndex": 108991, - "Kind": 3 - }, - { - "EndIndex": 109021, - "Kind": 3 - }, - { - "EndIndex": 109049, - "Kind": 3 - }, - { - "EndIndex": 109055, - "Kind": 3 - }, - { - "EndIndex": 109089, - "Kind": 3 - }, - { - "EndIndex": 109173, - "Kind": 3 - }, - { - "EndIndex": 109195, - "Kind": 3 - }, - { - "EndIndex": 109201, - "Kind": 3 - }, - { - "EndIndex": 109203, - "Kind": 3 - }, - { - "EndIndex": 109229, - "Kind": 3 - }, - { - "EndIndex": 109257, - "Kind": 3 - }, - { - "EndIndex": 109286, - "Kind": 3 - }, - { - "EndIndex": 109325, - "Kind": 3 - }, - { - "EndIndex": 109364, - "Kind": 3 - }, - { - "EndIndex": 109378, - "Kind": 3 - }, - { - "EndIndex": 109384, - "Kind": 3 - }, - { - "EndIndex": 109426, - "Kind": 3 - }, - { - "EndIndex": 109440, - "Kind": 3 - }, - { - "EndIndex": 109446, - "Kind": 3 - }, - { - "EndIndex": 109464, - "Kind": 3 - }, - { - "EndIndex": 109497, - "Kind": 3 - }, - { - "EndIndex": 109648, - "Kind": 3 - }, - { - "EndIndex": 109669, - "Kind": 3 - }, - { - "EndIndex": 109675, - "Kind": 3 - }, - { - "EndIndex": 109700, - "Kind": 3 - }, - { - "EndIndex": 109733, - "Kind": 3 - }, - { - "EndIndex": 109763, - "Kind": 3 - }, - { - "EndIndex": 109769, - "Kind": 3 - }, - { - "EndIndex": 109793, - "Kind": 3 - }, - { - "EndIndex": 109822, - "Kind": 3 - }, - { - "EndIndex": 109840, - "Kind": 3 - }, - { - "EndIndex": 109846, - "Kind": 3 - }, - { - "EndIndex": 109871, - "Kind": 3 - }, - { - "EndIndex": 109901, - "Kind": 3 - }, - { - "EndIndex": 109920, - "Kind": 3 - }, - { - "EndIndex": 109926, - "Kind": 3 - }, - { - "EndIndex": 109944, - "Kind": 3 - }, - { - "EndIndex": 109986, - "Kind": 3 - }, - { - "EndIndex": 110312, - "Kind": 3 - }, - { - "EndIndex": 110334, - "Kind": 3 - }, - { - "EndIndex": 110340, - "Kind": 3 - }, - { - "EndIndex": 110342, - "Kind": 3 - }, - { - "EndIndex": 110372, - "Kind": 3 - }, - { - "EndIndex": 110399, - "Kind": 3 - }, - { - "EndIndex": 110430, - "Kind": 3 - }, - { - "EndIndex": 110460, - "Kind": 3 - }, - { - "EndIndex": 110489, - "Kind": 3 - }, - { - "EndIndex": 110495, - "Kind": 3 - }, - { - "EndIndex": 110523, - "Kind": 3 - }, - { - "EndIndex": 110557, - "Kind": 3 - }, - { - "EndIndex": 110588, - "Kind": 3 - }, - { - "EndIndex": 110610, - "Kind": 3 - }, - { - "EndIndex": 110616, - "Kind": 3 - }, - { - "EndIndex": 110646, - "Kind": 3 - }, - { - "EndIndex": 110677, - "Kind": 3 - }, - { - "EndIndex": 110699, - "Kind": 3 - }, - { - "EndIndex": 110705, - "Kind": 3 - }, - { - "EndIndex": 110735, - "Kind": 3 - }, - { - "EndIndex": 110766, - "Kind": 3 - }, - { - "EndIndex": 110788, - "Kind": 3 - }, - { - "EndIndex": 110794, - "Kind": 3 - }, - { - "EndIndex": 110833, - "Kind": 3 - }, - { - "EndIndex": 110872, - "Kind": 3 - }, - { - "EndIndex": 110886, - "Kind": 3 - }, - { - "EndIndex": 110892, - "Kind": 3 - }, - { - "EndIndex": 110922, - "Kind": 3 - }, - { - "EndIndex": 110952, - "Kind": 3 - }, - { - "EndIndex": 110974, - "Kind": 3 - }, - { - "EndIndex": 110980, - "Kind": 3 - }, - { - "EndIndex": 111001, - "Kind": 3 - }, - { - "EndIndex": 111043, - "Kind": 3 - }, - { - "EndIndex": 111057, - "Kind": 3 - }, - { - "EndIndex": 111063, - "Kind": 3 - }, - { - "EndIndex": 111081, - "Kind": 3 - }, - { - "EndIndex": 111114, - "Kind": 3 - }, - { - "EndIndex": 111265, - "Kind": 3 - }, - { - "EndIndex": 111286, - "Kind": 3 - }, - { - "EndIndex": 111292, - "Kind": 3 - }, - { - "EndIndex": 111317, - "Kind": 3 - }, - { - "EndIndex": 111350, - "Kind": 3 - }, - { - "EndIndex": 111379, - "Kind": 3 - }, - { - "EndIndex": 111385, - "Kind": 3 - }, - { - "EndIndex": 111415, - "Kind": 3 - }, - { - "EndIndex": 111446, - "Kind": 3 - }, - { - "EndIndex": 111468, - "Kind": 3 - }, - { - "EndIndex": 111474, - "Kind": 3 - }, - { - "EndIndex": 111498, - "Kind": 3 - }, - { - "EndIndex": 111527, - "Kind": 3 - }, - { - "EndIndex": 111545, - "Kind": 3 - }, - { - "EndIndex": 111551, - "Kind": 3 - }, - { - "EndIndex": 111581, - "Kind": 3 - }, - { - "EndIndex": 111611, - "Kind": 3 - }, - { - "EndIndex": 111633, - "Kind": 3 - }, - { - "EndIndex": 111639, - "Kind": 3 - }, - { - "EndIndex": 111669, - "Kind": 3 - }, - { - "EndIndex": 111700, - "Kind": 3 - }, - { - "EndIndex": 111722, - "Kind": 3 - }, - { - "EndIndex": 111728, - "Kind": 3 - }, - { - "EndIndex": 111758, - "Kind": 3 - }, - { - "EndIndex": 111788, - "Kind": 3 - }, - { - "EndIndex": 111817, - "Kind": 3 - }, - { - "EndIndex": 111823, - "Kind": 3 - }, - { - "EndIndex": 111855, - "Kind": 3 - }, - { - "EndIndex": 111885, - "Kind": 3 - }, - { - "EndIndex": 111914, - "Kind": 3 - }, - { - "EndIndex": 111920, - "Kind": 3 - }, - { - "EndIndex": 111945, - "Kind": 3 - }, - { - "EndIndex": 111975, - "Kind": 3 - }, - { - "EndIndex": 111994, - "Kind": 3 - }, - { - "EndIndex": 112000, - "Kind": 3 - }, - { - "EndIndex": 112031, - "Kind": 3 - }, - { - "EndIndex": 112061, - "Kind": 3 - }, - { - "EndIndex": 112090, - "Kind": 3 - }, - { - "EndIndex": 112096, - "Kind": 3 - }, - { - "EndIndex": 112128, - "Kind": 3 - }, - { - "EndIndex": 112158, - "Kind": 3 - }, - { - "EndIndex": 112187, - "Kind": 3 - }, - { - "EndIndex": 112193, - "Kind": 3 - }, - { - "EndIndex": 112225, - "Kind": 3 - }, - { - "EndIndex": 112255, - "Kind": 3 - }, - { - "EndIndex": 112284, - "Kind": 3 - }, - { - "EndIndex": 112290, - "Kind": 3 - }, - { - "EndIndex": 112321, - "Kind": 3 - }, - { - "EndIndex": 112351, - "Kind": 3 - }, - { - "EndIndex": 112380, - "Kind": 3 - }, - { - "EndIndex": 112386, - "Kind": 3 - }, - { - "EndIndex": 112404, - "Kind": 3 - }, - { - "EndIndex": 112446, - "Kind": 3 - }, - { - "EndIndex": 112772, - "Kind": 3 - }, - { - "EndIndex": 112794, - "Kind": 3 - }, - { - "EndIndex": 112800, - "Kind": 3 - }, - { - "EndIndex": 112831, - "Kind": 3 - }, - { - "EndIndex": 112861, - "Kind": 3 - }, - { - "EndIndex": 112890, - "Kind": 3 - }, - { - "EndIndex": 112896, - "Kind": 3 - }, - { - "EndIndex": 112930, - "Kind": 3 - }, - { - "EndIndex": 113014, - "Kind": 3 - }, - { - "EndIndex": 113036, - "Kind": 3 - }, - { - "EndIndex": 113042, - "Kind": 3 - }, - { - "EndIndex": 113044, - "Kind": 3 - }, - { - "EndIndex": 113072, - "Kind": 3 - }, - { - "EndIndex": 113101, - "Kind": 3 - }, - { - "EndIndex": 113131, - "Kind": 3 - }, - { - "EndIndex": 113170, - "Kind": 3 - }, - { - "EndIndex": 113209, - "Kind": 3 - }, - { - "EndIndex": 113223, - "Kind": 3 - }, - { - "EndIndex": 113229, - "Kind": 3 - }, - { - "EndIndex": 113271, - "Kind": 3 - }, - { - "EndIndex": 113285, - "Kind": 3 - }, - { - "EndIndex": 113291, - "Kind": 3 - }, - { - "EndIndex": 113309, - "Kind": 3 - }, - { - "EndIndex": 113342, - "Kind": 3 - }, - { - "EndIndex": 113493, - "Kind": 3 - }, - { - "EndIndex": 113514, - "Kind": 3 - }, - { - "EndIndex": 113520, - "Kind": 3 - }, - { - "EndIndex": 113545, - "Kind": 3 - }, - { - "EndIndex": 113578, - "Kind": 3 - }, - { - "EndIndex": 113609, - "Kind": 3 - }, - { - "EndIndex": 113615, - "Kind": 3 - }, - { - "EndIndex": 113647, - "Kind": 3 - }, - { - "EndIndex": 113713, - "Kind": 3 - }, - { - "EndIndex": 113731, - "Kind": 3 - }, - { - "EndIndex": 113737, - "Kind": 3 - }, - { - "EndIndex": 113762, - "Kind": 3 - }, - { - "EndIndex": 113795, - "Kind": 3 - }, - { - "EndIndex": 113809, - "Kind": 3 - }, - { - "EndIndex": 113815, - "Kind": 3 - }, - { - "EndIndex": 113842, - "Kind": 3 - }, - { - "EndIndex": 113892, - "Kind": 3 - }, - { - "EndIndex": 113922, - "Kind": 3 - }, - { - "EndIndex": 113928, - "Kind": 3 - }, - { - "EndIndex": 113946, - "Kind": 3 - }, - { - "EndIndex": 113988, - "Kind": 3 - }, - { - "EndIndex": 114314, - "Kind": 3 - }, - { - "EndIndex": 114336, - "Kind": 3 - }, - { - "EndIndex": 114342, - "Kind": 3 - }, - { - "EndIndex": 114344, - "Kind": 3 - }, - { - "EndIndex": 114376, - "Kind": 3 - }, - { - "EndIndex": 114410, - "Kind": 3 - }, - { - "EndIndex": 114445, - "Kind": 3 - }, - { - "EndIndex": 114484, - "Kind": 3 - }, - { - "EndIndex": 114523, - "Kind": 3 - }, - { - "EndIndex": 114537, - "Kind": 3 - }, - { - "EndIndex": 114543, - "Kind": 3 - }, - { - "EndIndex": 114585, - "Kind": 3 - }, - { - "EndIndex": 114599, - "Kind": 3 - }, - { - "EndIndex": 114605, - "Kind": 3 - }, - { - "EndIndex": 114623, - "Kind": 3 - }, - { - "EndIndex": 114656, - "Kind": 3 - }, - { - "EndIndex": 114807, - "Kind": 3 - }, - { - "EndIndex": 114828, - "Kind": 3 - }, - { - "EndIndex": 114834, - "Kind": 3 - }, - { - "EndIndex": 114859, - "Kind": 3 - }, - { - "EndIndex": 114892, - "Kind": 3 - }, - { - "EndIndex": 114928, - "Kind": 3 - }, - { - "EndIndex": 114934, - "Kind": 3 - }, - { - "EndIndex": 114959, - "Kind": 3 - }, - { - "EndIndex": 114992, - "Kind": 3 - }, - { - "EndIndex": 115006, - "Kind": 3 - }, - { - "EndIndex": 115012, - "Kind": 3 - }, - { - "EndIndex": 115039, - "Kind": 3 - }, - { - "EndIndex": 115089, - "Kind": 3 - }, - { - "EndIndex": 115119, - "Kind": 3 - }, - { - "EndIndex": 115125, - "Kind": 3 - }, - { - "EndIndex": 115143, - "Kind": 3 - }, - { - "EndIndex": 115185, - "Kind": 3 - }, - { - "EndIndex": 115511, - "Kind": 3 - }, - { - "EndIndex": 115533, - "Kind": 3 - }, - { - "EndIndex": 115539, - "Kind": 3 - }, - { - "EndIndex": 115541, - "Kind": 3 - }, - { - "EndIndex": 115583, - "Kind": 3 - }, - { - "EndIndex": 116124, - "Kind": 3 - }, - { - "EndIndex": 116159, - "Kind": 3 - }, - { - "EndIndex": 116200, - "Kind": 3 - }, - { - "EndIndex": 116233, - "Kind": 3 - }, - { - "EndIndex": 116252, - "Kind": 3 - }, - { - "EndIndex": 116294, - "Kind": 3 - }, - { - "EndIndex": 116339, - "Kind": 3 - }, - { - "EndIndex": 116353, - "Kind": 3 - }, - { - "EndIndex": 116359, - "Kind": 3 - }, - { - "EndIndex": 116377, - "Kind": 3 - }, - { - "EndIndex": 116410, - "Kind": 3 - }, - { - "EndIndex": 116561, - "Kind": 3 - }, - { - "EndIndex": 116582, - "Kind": 3 - }, - { - "EndIndex": 116588, - "Kind": 3 - }, - { - "EndIndex": 116606, - "Kind": 3 - }, - { - "EndIndex": 116648, - "Kind": 3 - }, - { - "EndIndex": 116974, - "Kind": 3 - }, - { - "EndIndex": 116996, - "Kind": 3 - }, - { - "EndIndex": 117002, - "Kind": 3 - }, - { - "EndIndex": 117004, - "Kind": 3 - }, - { - "EndIndex": 117038, - "Kind": 3 - }, - { - "EndIndex": 117063, - "Kind": 3 - }, - { - "EndIndex": 117095, - "Kind": 3 - }, - { - "EndIndex": 117114, - "Kind": 3 - }, - { - "EndIndex": 117156, - "Kind": 3 - }, - { - "EndIndex": 117185, - "Kind": 3 - }, - { - "EndIndex": 117199, - "Kind": 3 - }, - { - "EndIndex": 117205, - "Kind": 3 - }, - { - "EndIndex": 117223, - "Kind": 3 - }, - { - "EndIndex": 117256, - "Kind": 3 - }, - { - "EndIndex": 117407, - "Kind": 3 - }, - { - "EndIndex": 117428, - "Kind": 3 - }, - { - "EndIndex": 117434, - "Kind": 3 - }, - { - "EndIndex": 117452, - "Kind": 3 - }, - { - "EndIndex": 117494, - "Kind": 3 - }, - { - "EndIndex": 117820, - "Kind": 3 - }, - { - "EndIndex": 117842, - "Kind": 3 - }, - { - "EndIndex": 117848, - "Kind": 3 - }, - { - "EndIndex": 117850, - "Kind": 3 - }, - { - "EndIndex": 117884, - "Kind": 3 - }, - { - "EndIndex": 117912, - "Kind": 3 - }, - { - "EndIndex": 117944, - "Kind": 3 - }, - { - "EndIndex": 117963, - "Kind": 3 - }, - { - "EndIndex": 118005, - "Kind": 3 - }, - { - "EndIndex": 118037, - "Kind": 3 - }, - { - "EndIndex": 118051, - "Kind": 3 - }, - { - "EndIndex": 118057, - "Kind": 3 - }, - { - "EndIndex": 118075, - "Kind": 3 - }, - { - "EndIndex": 118108, - "Kind": 3 - }, - { - "EndIndex": 118259, - "Kind": 3 - }, - { - "EndIndex": 118280, - "Kind": 3 - }, - { - "EndIndex": 118286, - "Kind": 3 - }, - { - "EndIndex": 118304, - "Kind": 3 - }, - { - "EndIndex": 118346, - "Kind": 3 - }, - { - "EndIndex": 118672, - "Kind": 3 - }, - { - "EndIndex": 118694, - "Kind": 3 - }, - { - "EndIndex": 118700, - "Kind": 3 - }, - { - "EndIndex": 118702, - "Kind": 3 - }, - { - "EndIndex": 118732, - "Kind": 3 - }, - { - "EndIndex": 118776, - "Kind": 3 - }, - { - "EndIndex": 118791, - "Kind": 3 - }, - { - "EndIndex": 118817, - "Kind": 3 - }, - { - "EndIndex": 118844, - "Kind": 3 - }, - { - "EndIndex": 118858, - "Kind": 3 - }, - { - "EndIndex": 118864, - "Kind": 3 - }, - { - "EndIndex": 118895, - "Kind": 3 - }, - { - "EndIndex": 118910, - "Kind": 3 - }, - { - "EndIndex": 118938, - "Kind": 3 - }, - { - "EndIndex": 118967, - "Kind": 3 - }, - { - "EndIndex": 118981, - "Kind": 3 - }, - { - "EndIndex": 118987, - "Kind": 3 - }, - { - "EndIndex": 119021, - "Kind": 3 - }, - { - "EndIndex": 119063, - "Kind": 3 - }, - { - "EndIndex": 119084, - "Kind": 3 - }, - { - "EndIndex": 119090, - "Kind": 3 - }, - { - "EndIndex": 119109, - "Kind": 3 - }, - { - "EndIndex": 119148, - "Kind": 3 - }, - { - "EndIndex": 119187, - "Kind": 3 - }, - { - "EndIndex": 119201, - "Kind": 3 - }, - { - "EndIndex": 119207, - "Kind": 3 - }, - { - "EndIndex": 119249, - "Kind": 3 - }, - { - "EndIndex": 119297, - "Kind": 3 - }, - { - "EndIndex": 119311, - "Kind": 3 - }, - { - "EndIndex": 119317, - "Kind": 3 - }, - { - "EndIndex": 119335, - "Kind": 3 - }, - { - "EndIndex": 119368, - "Kind": 3 - }, - { - "EndIndex": 119519, - "Kind": 3 - }, - { - "EndIndex": 119540, - "Kind": 3 - }, - { - "EndIndex": 119546, - "Kind": 3 - }, - { - "EndIndex": 119573, - "Kind": 3 - }, - { - "EndIndex": 119603, - "Kind": 3 - }, - { - "EndIndex": 119609, - "Kind": 3 - }, - { - "EndIndex": 119634, - "Kind": 3 - }, - { - "EndIndex": 119664, - "Kind": 3 - }, - { - "EndIndex": 119683, - "Kind": 3 - }, - { - "EndIndex": 119689, - "Kind": 3 - }, - { - "EndIndex": 119730, - "Kind": 3 - }, - { - "EndIndex": 119779, - "Kind": 3 - }, - { - "EndIndex": 119800, - "Kind": 3 - }, - { - "EndIndex": 119806, - "Kind": 3 - }, - { - "EndIndex": 119842, - "Kind": 3 - }, - { - "EndIndex": 119863, - "Kind": 3 - }, - { - "EndIndex": 119869, - "Kind": 3 - }, - { - "EndIndex": 119893, - "Kind": 3 - }, - { - "EndIndex": 119922, - "Kind": 3 - }, - { - "EndIndex": 119941, - "Kind": 3 - }, - { - "EndIndex": 119947, - "Kind": 3 - }, - { - "EndIndex": 119965, - "Kind": 3 - }, - { - "EndIndex": 120007, - "Kind": 3 - }, - { - "EndIndex": 120333, - "Kind": 3 - }, - { - "EndIndex": 120355, - "Kind": 3 - }, - { - "EndIndex": 120361, - "Kind": 3 - }, - { - "EndIndex": 120376, - "Kind": 3 - }, - { - "EndIndex": 120413, - "Kind": 3 - }, - { - "EndIndex": 120427, - "Kind": 3 - }, - { - "EndIndex": 120433, - "Kind": 3 - }, - { - "EndIndex": 120448, - "Kind": 3 - }, - { - "EndIndex": 120478, - "Kind": 3 - }, - { - "EndIndex": 120492, - "Kind": 3 - }, - { - "EndIndex": 120498, - "Kind": 3 - }, - { - "EndIndex": 120513, - "Kind": 3 - }, - { - "EndIndex": 120534, - "Kind": 3 - }, - { - "EndIndex": 120548, - "Kind": 3 - }, - { - "EndIndex": 120554, - "Kind": 3 - }, - { - "EndIndex": 120585, - "Kind": 3 - }, - { - "EndIndex": 120679, - "Kind": 3 - }, - { - "EndIndex": 120693, - "Kind": 3 - }, - { - "EndIndex": 120699, - "Kind": 3 - }, - { - "EndIndex": 120701, - "Kind": 3 - }, - { - "EndIndex": 120734, - "Kind": 3 - }, - { - "EndIndex": 120768, - "Kind": 3 - }, - { - "EndIndex": 120801, - "Kind": 3 - }, - { - "EndIndex": 120820, - "Kind": 3 - }, - { - "EndIndex": 120862, - "Kind": 3 - }, - { - "EndIndex": 120900, - "Kind": 3 - }, - { - "EndIndex": 120914, - "Kind": 3 - }, - { - "EndIndex": 120920, - "Kind": 3 - }, - { - "EndIndex": 120938, - "Kind": 3 - }, - { - "EndIndex": 120971, - "Kind": 3 - }, - { - "EndIndex": 121122, - "Kind": 3 - }, - { - "EndIndex": 121143, - "Kind": 3 - }, - { - "EndIndex": 121149, - "Kind": 3 - }, - { - "EndIndex": 121167, - "Kind": 3 - }, - { - "EndIndex": 121209, - "Kind": 3 - }, - { - "EndIndex": 121535, - "Kind": 3 - }, - { - "EndIndex": 121557, - "Kind": 3 - }, - { - "EndIndex": 121563, - "Kind": 3 - }, - { - "EndIndex": 121565, - "Kind": 3 - }, - { - "EndIndex": 121606, - "Kind": 3 - }, - { - "EndIndex": 121626, - "Kind": 3 - }, - { - "EndIndex": 121659, - "Kind": 3 - }, - { - "EndIndex": 121678, - "Kind": 3 - }, - { - "EndIndex": 121720, - "Kind": 3 - }, - { - "EndIndex": 121744, - "Kind": 3 - }, - { - "EndIndex": 121758, - "Kind": 3 - }, - { - "EndIndex": 121764, - "Kind": 3 - }, - { - "EndIndex": 121782, - "Kind": 3 - }, - { - "EndIndex": 121815, - "Kind": 3 - }, - { - "EndIndex": 121966, - "Kind": 3 - }, - { - "EndIndex": 121987, - "Kind": 3 - }, - { - "EndIndex": 121993, - "Kind": 3 - }, - { - "EndIndex": 122011, - "Kind": 3 - }, - { - "EndIndex": 122053, - "Kind": 3 - }, - { - "EndIndex": 122379, - "Kind": 3 - }, - { - "EndIndex": 122401, - "Kind": 3 - }, - { - "EndIndex": 122407, - "Kind": 3 - }, - { - "EndIndex": 122409, - "Kind": 3 - }, - { - "EndIndex": 122440, - "Kind": 3 - }, - { - "EndIndex": 122461, - "Kind": 3 - }, - { - "EndIndex": 122490, - "Kind": 3 - }, - { - "EndIndex": 122509, - "Kind": 3 - }, - { - "EndIndex": 122551, - "Kind": 3 - }, - { - "EndIndex": 122576, - "Kind": 3 - }, - { - "EndIndex": 122590, - "Kind": 3 - }, - { - "EndIndex": 122596, - "Kind": 3 - }, - { - "EndIndex": 122614, - "Kind": 3 - }, - { - "EndIndex": 122647, - "Kind": 3 - }, - { - "EndIndex": 122798, - "Kind": 3 - }, - { - "EndIndex": 122819, - "Kind": 3 - }, - { - "EndIndex": 122825, - "Kind": 3 - }, - { - "EndIndex": 122843, - "Kind": 3 - }, - { - "EndIndex": 122885, - "Kind": 3 - }, - { - "EndIndex": 123211, - "Kind": 3 - }, - { - "EndIndex": 123233, - "Kind": 3 - }, - { - "EndIndex": 123239, - "Kind": 3 - }, - { - "EndIndex": 123241, - "Kind": 3 - }, - { - "EndIndex": 123271, - "Kind": 3 - }, - { - "EndIndex": 123403, - "Kind": 3 - }, - { - "EndIndex": 123433, - "Kind": 3 - }, - { - "EndIndex": 123452, - "Kind": 3 - }, - { - "EndIndex": 123494, - "Kind": 3 - }, - { - "EndIndex": 123630, - "Kind": 3 - }, - { - "EndIndex": 123644, - "Kind": 3 - }, - { - "EndIndex": 123650, - "Kind": 3 - }, - { - "EndIndex": 123668, - "Kind": 3 - }, - { - "EndIndex": 123701, - "Kind": 3 - }, - { - "EndIndex": 123852, - "Kind": 3 - }, - { - "EndIndex": 123873, - "Kind": 3 - }, - { - "EndIndex": 123879, - "Kind": 3 - }, - { - "EndIndex": 123897, - "Kind": 3 - }, - { - "EndIndex": 123939, - "Kind": 3 - }, - { - "EndIndex": 124265, - "Kind": 3 - }, - { - "EndIndex": 124287, - "Kind": 3 - }, - { - "EndIndex": 124293, - "Kind": 3 - }, - { - "EndIndex": 124295, - "Kind": 3 - }, - { - "EndIndex": 124330, - "Kind": 3 - }, - { - "EndIndex": 124358, - "Kind": 3 - }, - { - "EndIndex": 124393, - "Kind": 3 - }, - { - "EndIndex": 124412, - "Kind": 3 - }, - { - "EndIndex": 124454, - "Kind": 3 - }, - { - "EndIndex": 124486, - "Kind": 3 - }, - { - "EndIndex": 124500, - "Kind": 3 - }, - { - "EndIndex": 124506, - "Kind": 3 - }, - { - "EndIndex": 124524, - "Kind": 3 - }, - { - "EndIndex": 124557, - "Kind": 3 - }, - { - "EndIndex": 124708, - "Kind": 3 - }, - { - "EndIndex": 124729, - "Kind": 3 - }, - { - "EndIndex": 124735, - "Kind": 3 - }, - { - "EndIndex": 124753, - "Kind": 3 - }, - { - "EndIndex": 124795, - "Kind": 3 - }, - { - "EndIndex": 125121, - "Kind": 3 - }, - { - "EndIndex": 125143, - "Kind": 3 - }, - { - "EndIndex": 125149, - "Kind": 3 - }, - { - "EndIndex": 125151, - "Kind": 3 - }, - { - "EndIndex": 125199, - "Kind": 3 - }, - { - "EndIndex": 125226, - "Kind": 3 - }, - { - "EndIndex": 125266, - "Kind": 3 - }, - { - "EndIndex": 125285, - "Kind": 3 - }, - { - "EndIndex": 125327, - "Kind": 3 - }, - { - "EndIndex": 125358, - "Kind": 3 - }, - { - "EndIndex": 125372, - "Kind": 3 - }, - { - "EndIndex": 125378, - "Kind": 3 - }, - { - "EndIndex": 125396, - "Kind": 3 - }, - { - "EndIndex": 125429, - "Kind": 3 - }, - { - "EndIndex": 125580, - "Kind": 3 - }, - { - "EndIndex": 125601, - "Kind": 3 - }, - { - "EndIndex": 125607, - "Kind": 3 - }, - { - "EndIndex": 125625, - "Kind": 3 - }, - { - "EndIndex": 125667, - "Kind": 3 - }, - { - "EndIndex": 125993, - "Kind": 3 - }, - { - "EndIndex": 126015, - "Kind": 3 - }, - { - "EndIndex": 126021, - "Kind": 3 - }, - { - "EndIndex": 126023, - "Kind": 3 - }, - { - "EndIndex": 126056, - "Kind": 3 - }, - { - "EndIndex": 126081, - "Kind": 3 - }, - { - "EndIndex": 126114, - "Kind": 3 - }, - { - "EndIndex": 126133, - "Kind": 3 - }, - { - "EndIndex": 126175, - "Kind": 3 - }, - { - "EndIndex": 126204, - "Kind": 3 - }, - { - "EndIndex": 126218, - "Kind": 3 - }, - { - "EndIndex": 126224, - "Kind": 3 - }, - { - "EndIndex": 126242, - "Kind": 3 - }, - { - "EndIndex": 126275, - "Kind": 3 - }, - { - "EndIndex": 126426, - "Kind": 3 - }, - { - "EndIndex": 126447, - "Kind": 3 - }, - { - "EndIndex": 126453, - "Kind": 3 - }, - { - "EndIndex": 126471, - "Kind": 3 - }, - { - "EndIndex": 126513, - "Kind": 3 - }, - { - "EndIndex": 126839, - "Kind": 3 - }, - { - "EndIndex": 126861, - "Kind": 3 - }, - { - "EndIndex": 126867, - "Kind": 3 - }, - { - "EndIndex": 126869, - "Kind": 3 - }, - { - "EndIndex": 126917, - "Kind": 3 - }, - { - "EndIndex": 126944, - "Kind": 3 - }, - { - "EndIndex": 126984, - "Kind": 3 - }, - { - "EndIndex": 127003, - "Kind": 3 - }, - { - "EndIndex": 127045, - "Kind": 3 - }, - { - "EndIndex": 127076, - "Kind": 3 - }, - { - "EndIndex": 127090, - "Kind": 3 - }, - { - "EndIndex": 127096, - "Kind": 3 - }, - { - "EndIndex": 127114, - "Kind": 3 - }, - { - "EndIndex": 127147, - "Kind": 3 - }, - { - "EndIndex": 127298, - "Kind": 3 - }, - { - "EndIndex": 127319, - "Kind": 3 - }, - { - "EndIndex": 127325, - "Kind": 3 - }, - { - "EndIndex": 127343, - "Kind": 3 - }, - { - "EndIndex": 127385, - "Kind": 3 - }, - { - "EndIndex": 127711, - "Kind": 3 - }, - { - "EndIndex": 127733, - "Kind": 3 - }, - { - "EndIndex": 127739, - "Kind": 3 - }, - { - "EndIndex": 127741, - "Kind": 3 - }, - { - "EndIndex": 127787, - "Kind": 3 - }, - { - "EndIndex": 127812, - "Kind": 3 - }, - { - "EndIndex": 127850, - "Kind": 3 - }, - { - "EndIndex": 127869, - "Kind": 3 - }, - { - "EndIndex": 127911, - "Kind": 3 - }, - { - "EndIndex": 127940, - "Kind": 3 - }, - { - "EndIndex": 127954, - "Kind": 3 - }, - { - "EndIndex": 127960, - "Kind": 3 - }, - { - "EndIndex": 127978, - "Kind": 3 - }, - { - "EndIndex": 128011, - "Kind": 3 - }, - { - "EndIndex": 128162, - "Kind": 3 - }, - { - "EndIndex": 128183, - "Kind": 3 - }, - { - "EndIndex": 128189, - "Kind": 3 - }, - { - "EndIndex": 128207, - "Kind": 3 - }, - { - "EndIndex": 128249, - "Kind": 3 - }, - { - "EndIndex": 128575, - "Kind": 3 - }, - { - "EndIndex": 128597, - "Kind": 3 - }, - { - "EndIndex": 128603, - "Kind": 3 - }, - { - "EndIndex": 128605, - "Kind": 3 - }, - { - "EndIndex": 128641, - "Kind": 3 - }, - { - "EndIndex": 128699, - "Kind": 3 - }, - { - "EndIndex": 128735, - "Kind": 3 - }, - { - "EndIndex": 128754, - "Kind": 3 - }, - { - "EndIndex": 128796, - "Kind": 3 - }, - { - "EndIndex": 128858, - "Kind": 3 - }, - { - "EndIndex": 128872, - "Kind": 3 - }, - { - "EndIndex": 128878, - "Kind": 3 - }, - { - "EndIndex": 128896, - "Kind": 3 - }, - { - "EndIndex": 128929, - "Kind": 3 - }, - { - "EndIndex": 129080, - "Kind": 3 - }, - { - "EndIndex": 129101, - "Kind": 3 - }, - { - "EndIndex": 129107, - "Kind": 3 - }, - { - "EndIndex": 129125, - "Kind": 3 - }, - { - "EndIndex": 129167, - "Kind": 3 - }, - { - "EndIndex": 129493, - "Kind": 3 - }, - { - "EndIndex": 129515, - "Kind": 3 - }, - { - "EndIndex": 129521, - "Kind": 3 - }, - { - "EndIndex": 129523, - "Kind": 3 - }, - { - "EndIndex": 129551, - "Kind": 3 - }, - { - "EndIndex": 129583, - "Kind": 3 - }, - { - "EndIndex": 129609, - "Kind": 3 - }, - { - "EndIndex": 129628, - "Kind": 3 - }, - { - "EndIndex": 129670, - "Kind": 3 - }, - { - "EndIndex": 129706, - "Kind": 3 - }, - { - "EndIndex": 129720, - "Kind": 3 - }, - { - "EndIndex": 129726, - "Kind": 3 - }, - { - "EndIndex": 129744, - "Kind": 3 - }, - { - "EndIndex": 129777, - "Kind": 3 - }, - { - "EndIndex": 129928, - "Kind": 3 - }, - { - "EndIndex": 129949, - "Kind": 3 - }, - { - "EndIndex": 129955, - "Kind": 3 - }, - { - "EndIndex": 129973, - "Kind": 3 - }, - { - "EndIndex": 130015, - "Kind": 3 - }, - { - "EndIndex": 130341, - "Kind": 3 - }, - { - "EndIndex": 130363, - "Kind": 3 - }, - { - "EndIndex": 130369, - "Kind": 3 - }, - { - "EndIndex": 130371, - "Kind": 3 - }, - { - "EndIndex": 130394, - "Kind": 3 - }, - { - "EndIndex": 130424, - "Kind": 3 - }, - { - "EndIndex": 130457, - "Kind": 3 - }, - { - "EndIndex": 130511, - "Kind": 3 - }, - { - "EndIndex": 130538, - "Kind": 3 - }, - { - "EndIndex": 130557, - "Kind": 3 - }, - { - "EndIndex": 130599, - "Kind": 3 - }, - { - "EndIndex": 130657, - "Kind": 3 - }, - { - "EndIndex": 130671, - "Kind": 3 - }, - { - "EndIndex": 130677, - "Kind": 3 - }, - { - "EndIndex": 130695, - "Kind": 3 - }, - { - "EndIndex": 130728, - "Kind": 3 - }, - { - "EndIndex": 130879, - "Kind": 3 - }, - { - "EndIndex": 130900, - "Kind": 3 - }, - { - "EndIndex": 130906, - "Kind": 3 - }, - { - "EndIndex": 130924, - "Kind": 3 - }, - { - "EndIndex": 130966, - "Kind": 3 - }, - { - "EndIndex": 131292, - "Kind": 3 - }, - { - "EndIndex": 131314, - "Kind": 3 - }, - { - "EndIndex": 131320, - "Kind": 3 - }, - { - "EndIndex": 131322, - "Kind": 3 - }, - { - "EndIndex": 131355, - "Kind": 3 - }, - { - "EndIndex": 131383, - "Kind": 3 - }, - { - "EndIndex": 131416, - "Kind": 3 - }, - { - "EndIndex": 131435, - "Kind": 3 - }, - { - "EndIndex": 131477, - "Kind": 3 - }, - { - "EndIndex": 131509, - "Kind": 3 - }, - { - "EndIndex": 131523, - "Kind": 3 - }, - { - "EndIndex": 131529, - "Kind": 3 - }, - { - "EndIndex": 131547, - "Kind": 3 - }, - { - "EndIndex": 131580, - "Kind": 3 - }, - { - "EndIndex": 131731, - "Kind": 3 - }, - { - "EndIndex": 131752, - "Kind": 3 - }, - { - "EndIndex": 131758, - "Kind": 3 - }, - { - "EndIndex": 131776, - "Kind": 3 - }, - { - "EndIndex": 131818, - "Kind": 3 - }, - { - "EndIndex": 132144, - "Kind": 3 - }, - { - "EndIndex": 132166, - "Kind": 3 - }, - { - "EndIndex": 132172, - "Kind": 3 - }, - { - "EndIndex": 132174, - "Kind": 3 - }, - { - "EndIndex": 132209, - "Kind": 3 - }, - { - "EndIndex": 132232, - "Kind": 3 - }, - { - "EndIndex": 132267, - "Kind": 3 - }, - { - "EndIndex": 132286, - "Kind": 3 - }, - { - "EndIndex": 132328, - "Kind": 3 - }, - { - "EndIndex": 132355, - "Kind": 3 - }, - { - "EndIndex": 132369, - "Kind": 3 - }, - { - "EndIndex": 132375, - "Kind": 3 - }, - { - "EndIndex": 132393, - "Kind": 3 - }, - { - "EndIndex": 132426, - "Kind": 3 - }, - { - "EndIndex": 132577, - "Kind": 3 - }, - { - "EndIndex": 132598, - "Kind": 3 - }, - { - "EndIndex": 132604, - "Kind": 3 - }, - { - "EndIndex": 132622, - "Kind": 3 - }, - { - "EndIndex": 132664, - "Kind": 3 - }, - { - "EndIndex": 132990, - "Kind": 3 - }, - { - "EndIndex": 133012, - "Kind": 3 - }, - { - "EndIndex": 133018, - "Kind": 3 - }, - { - "EndIndex": 133020, - "Kind": 3 - }, - { - "EndIndex": 133064, - "Kind": 3 - }, - { - "EndIndex": 133104, - "Kind": 3 - }, - { - "EndIndex": 133140, - "Kind": 3 - }, - { - "EndIndex": 133159, - "Kind": 3 - }, - { - "EndIndex": 133201, - "Kind": 3 - }, - { - "EndIndex": 133245, - "Kind": 3 - }, - { - "EndIndex": 133259, - "Kind": 3 - }, - { - "EndIndex": 133265, - "Kind": 3 - }, - { - "EndIndex": 133283, - "Kind": 3 - }, - { - "EndIndex": 133316, - "Kind": 3 - }, - { - "EndIndex": 133467, - "Kind": 3 - }, - { - "EndIndex": 133488, - "Kind": 3 - }, - { - "EndIndex": 133494, - "Kind": 3 - }, - { - "EndIndex": 133512, - "Kind": 3 - }, - { - "EndIndex": 133554, - "Kind": 3 - }, - { - "EndIndex": 133880, - "Kind": 3 - }, - { - "EndIndex": 133902, - "Kind": 3 - }, - { - "EndIndex": 133908, - "Kind": 3 - }, - { - "EndIndex": 133910, - "Kind": 3 - }, - { - "EndIndex": 133941, - "Kind": 3 - }, - { - "EndIndex": 134035, - "Kind": 3 - }, - { - "EndIndex": 134066, - "Kind": 3 - }, - { - "EndIndex": 134085, - "Kind": 3 - }, - { - "EndIndex": 134127, - "Kind": 3 - }, - { - "EndIndex": 134225, - "Kind": 3 - }, - { - "EndIndex": 134239, - "Kind": 3 - }, - { - "EndIndex": 134245, - "Kind": 3 - }, - { - "EndIndex": 134263, - "Kind": 3 - }, - { - "EndIndex": 134296, - "Kind": 3 - }, - { - "EndIndex": 134447, - "Kind": 3 - }, - { - "EndIndex": 134468, - "Kind": 3 - }, - { - "EndIndex": 134474, - "Kind": 3 - }, - { - "EndIndex": 134492, - "Kind": 3 - }, - { - "EndIndex": 134534, - "Kind": 3 - }, - { - "EndIndex": 134860, - "Kind": 3 - }, - { - "EndIndex": 134882, - "Kind": 3 - }, - { - "EndIndex": 134888, - "Kind": 3 - }, - { - "EndIndex": 134890, - "Kind": 3 - }, - { - "EndIndex": 134927, - "Kind": 3 - }, - { - "EndIndex": 134965, - "Kind": 3 - }, - { - "EndIndex": 134996, - "Kind": 3 - }, - { - "EndIndex": 135015, - "Kind": 3 - }, - { - "EndIndex": 135057, - "Kind": 3 - }, - { - "EndIndex": 135099, - "Kind": 3 - }, - { - "EndIndex": 135113, - "Kind": 3 - }, - { - "EndIndex": 135119, - "Kind": 3 - }, - { - "EndIndex": 135137, - "Kind": 3 - }, - { - "EndIndex": 135170, - "Kind": 3 - }, - { - "EndIndex": 135321, - "Kind": 3 - }, - { - "EndIndex": 135342, - "Kind": 3 - }, - { - "EndIndex": 135348, - "Kind": 3 - }, - { - "EndIndex": 135366, - "Kind": 3 - }, - { - "EndIndex": 135408, - "Kind": 3 - }, - { - "EndIndex": 135734, - "Kind": 3 - }, - { - "EndIndex": 135756, - "Kind": 3 - }, - { - "EndIndex": 135762, - "Kind": 3 - }, - { - "EndIndex": 135764, - "Kind": 3 - }, - { - "EndIndex": 135785, - "Kind": 3 - }, - { - "EndIndex": 135816, - "Kind": 3 - }, - { - "EndIndex": 135879, - "Kind": 3 - }, - { - "EndIndex": 135908, - "Kind": 3 - }, - { - "EndIndex": 135927, - "Kind": 3 - }, - { - "EndIndex": 135969, - "Kind": 3 - }, - { - "EndIndex": 136036, - "Kind": 3 - }, - { - "EndIndex": 136050, - "Kind": 3 - }, - { - "EndIndex": 136056, - "Kind": 3 - }, - { - "EndIndex": 136074, - "Kind": 3 - }, - { - "EndIndex": 136107, - "Kind": 3 - }, - { - "EndIndex": 136258, - "Kind": 3 - }, - { - "EndIndex": 136279, - "Kind": 3 - }, - { - "EndIndex": 136285, - "Kind": 3 - }, - { - "EndIndex": 136312, - "Kind": 3 - }, - { - "EndIndex": 136342, - "Kind": 3 - }, - { - "EndIndex": 136348, - "Kind": 3 - }, - { - "EndIndex": 136372, - "Kind": 3 - }, - { - "EndIndex": 136401, - "Kind": 3 - }, - { - "EndIndex": 136420, - "Kind": 3 - }, - { - "EndIndex": 136426, - "Kind": 3 - }, - { - "EndIndex": 136444, - "Kind": 3 - }, - { - "EndIndex": 136486, - "Kind": 3 - }, - { - "EndIndex": 136812, - "Kind": 3 - }, - { - "EndIndex": 136834, - "Kind": 3 - }, - { - "EndIndex": 136840, - "Kind": 3 - }, - { - "EndIndex": 136855, - "Kind": 3 - }, - { - "EndIndex": 136875, - "Kind": 3 - }, - { - "EndIndex": 136904, - "Kind": 3 - }, - { - "EndIndex": 136918, - "Kind": 3 - }, - { - "EndIndex": 136924, - "Kind": 3 - }, - { - "EndIndex": 136939, - "Kind": 3 - }, - { - "EndIndex": 136960, - "Kind": 3 - }, - { - "EndIndex": 136983, - "Kind": 3 - }, - { - "EndIndex": 136997, - "Kind": 3 - }, - { - "EndIndex": 137003, - "Kind": 3 - }, - { - "EndIndex": 137018, - "Kind": 3 - }, - { - "EndIndex": 137039, - "Kind": 3 - }, - { - "EndIndex": 137062, - "Kind": 3 - }, - { - "EndIndex": 137076, - "Kind": 3 - }, - { - "EndIndex": 137082, - "Kind": 3 - }, - { - "EndIndex": 137084, - "Kind": 3 - }, - { - "EndIndex": 137115, - "Kind": 3 - }, - { - "EndIndex": 137188, - "Kind": 3 - }, - { - "EndIndex": 137219, - "Kind": 3 - }, - { - "EndIndex": 137238, - "Kind": 3 - }, - { - "EndIndex": 137280, - "Kind": 3 - }, - { - "EndIndex": 137357, - "Kind": 3 - }, - { - "EndIndex": 137371, - "Kind": 3 - }, - { - "EndIndex": 137377, - "Kind": 3 - }, - { - "EndIndex": 137395, - "Kind": 3 - }, - { - "EndIndex": 137428, - "Kind": 3 - }, - { - "EndIndex": 137579, - "Kind": 3 - }, - { - "EndIndex": 137600, - "Kind": 3 - }, - { - "EndIndex": 137606, - "Kind": 3 - }, - { - "EndIndex": 137624, - "Kind": 3 - }, - { - "EndIndex": 137666, - "Kind": 3 - }, - { - "EndIndex": 137992, - "Kind": 3 - }, - { - "EndIndex": 138014, - "Kind": 3 - }, - { - "EndIndex": 138020, - "Kind": 3 - }, - { - "EndIndex": 138022, - "Kind": 3 - }, - { - "EndIndex": 138060, - "Kind": 3 - }, - { - "EndIndex": 138089, - "Kind": 3 - }, - { - "EndIndex": 138123, - "Kind": 3 - }, - { - "EndIndex": 138142, - "Kind": 3 - }, - { - "EndIndex": 138184, - "Kind": 3 - }, - { - "EndIndex": 138217, - "Kind": 3 - }, - { - "EndIndex": 138231, - "Kind": 3 - }, - { - "EndIndex": 138237, - "Kind": 3 - }, - { - "EndIndex": 138255, - "Kind": 3 - }, - { - "EndIndex": 138288, - "Kind": 3 - }, - { - "EndIndex": 138439, - "Kind": 3 - }, - { - "EndIndex": 138460, - "Kind": 3 - }, - { - "EndIndex": 138466, - "Kind": 3 - }, - { - "EndIndex": 138484, - "Kind": 3 - }, - { - "EndIndex": 138526, - "Kind": 3 - }, - { - "EndIndex": 138852, - "Kind": 3 - }, - { - "EndIndex": 138874, - "Kind": 3 - }, - { - "EndIndex": 138880, - "Kind": 3 - }, - { - "EndIndex": 138882, - "Kind": 3 - }, - { - "EndIndex": 138914, - "Kind": 3 - }, - { - "EndIndex": 138950, - "Kind": 3 - }, - { - "EndIndex": 138978, - "Kind": 3 - }, - { - "EndIndex": 138997, - "Kind": 3 - }, - { - "EndIndex": 139039, - "Kind": 3 - }, - { - "EndIndex": 139079, - "Kind": 3 - }, - { - "EndIndex": 139093, - "Kind": 3 - }, - { - "EndIndex": 139099, - "Kind": 3 - }, - { - "EndIndex": 139117, - "Kind": 3 - }, - { - "EndIndex": 139150, - "Kind": 3 - }, - { - "EndIndex": 139301, - "Kind": 3 - }, - { - "EndIndex": 139322, - "Kind": 3 - }, - { - "EndIndex": 139328, - "Kind": 3 - }, - { - "EndIndex": 139346, - "Kind": 3 - }, - { - "EndIndex": 139388, - "Kind": 3 - }, - { - "EndIndex": 139714, - "Kind": 3 - }, - { - "EndIndex": 139736, - "Kind": 3 - }, - { - "EndIndex": 139742, - "Kind": 3 - }, - { - "EndIndex": 139744, - "Kind": 3 - }, - { - "EndIndex": 139778, - "Kind": 3 - }, - { - "EndIndex": 139808, - "Kind": 3 - }, - { - "EndIndex": 139842, - "Kind": 3 - }, - { - "EndIndex": 139861, - "Kind": 3 - }, - { - "EndIndex": 139903, - "Kind": 3 - }, - { - "EndIndex": 139937, - "Kind": 3 - }, - { - "EndIndex": 139951, - "Kind": 3 - }, - { - "EndIndex": 139957, - "Kind": 3 - }, - { - "EndIndex": 139975, - "Kind": 3 - }, - { - "EndIndex": 140008, - "Kind": 3 - }, - { - "EndIndex": 140159, - "Kind": 3 - }, - { - "EndIndex": 140180, - "Kind": 3 - }, - { - "EndIndex": 140186, - "Kind": 3 - }, - { - "EndIndex": 140204, - "Kind": 3 - }, - { - "EndIndex": 140246, - "Kind": 3 - }, - { - "EndIndex": 140572, - "Kind": 3 - }, - { - "EndIndex": 140594, - "Kind": 3 - }, - { - "EndIndex": 140600, - "Kind": 3 - }, - { - "EndIndex": 140602, - "Kind": 3 - }, - { - "EndIndex": 140637, - "Kind": 3 - }, - { - "EndIndex": 140683, - "Kind": 3 - }, - { - "EndIndex": 140718, - "Kind": 3 - }, - { - "EndIndex": 140737, - "Kind": 3 - }, - { - "EndIndex": 140779, - "Kind": 3 - }, - { - "EndIndex": 140829, - "Kind": 3 - }, - { - "EndIndex": 140843, - "Kind": 3 - }, - { - "EndIndex": 140849, - "Kind": 3 - }, - { - "EndIndex": 140867, - "Kind": 3 - }, - { - "EndIndex": 140900, - "Kind": 3 - }, - { - "EndIndex": 141051, - "Kind": 3 - }, - { - "EndIndex": 141072, - "Kind": 3 - }, - { - "EndIndex": 141078, - "Kind": 3 - }, - { - "EndIndex": 141096, - "Kind": 3 - }, - { - "EndIndex": 141138, - "Kind": 3 - }, - { - "EndIndex": 141464, - "Kind": 3 - }, - { - "EndIndex": 141486, - "Kind": 3 - }, - { - "EndIndex": 141492, - "Kind": 3 - }, - { - "EndIndex": 141494, - "Kind": 3 - }, - { - "EndIndex": 141524, - "Kind": 3 - }, - { - "EndIndex": 141554, - "Kind": 3 - }, - { - "EndIndex": 141580, - "Kind": 3 - }, - { - "EndIndex": 141599, - "Kind": 3 - }, - { - "EndIndex": 141641, - "Kind": 3 - }, - { - "EndIndex": 141675, - "Kind": 3 - }, - { - "EndIndex": 141689, - "Kind": 3 - }, - { - "EndIndex": 141695, - "Kind": 3 - }, - { - "EndIndex": 141713, - "Kind": 3 - }, - { - "EndIndex": 141746, - "Kind": 3 - }, - { - "EndIndex": 141897, - "Kind": 3 - }, - { - "EndIndex": 141918, - "Kind": 3 - }, - { - "EndIndex": 141924, - "Kind": 3 - }, - { - "EndIndex": 141948, - "Kind": 3 - }, - { - "EndIndex": 141977, - "Kind": 3 - }, - { - "EndIndex": 141996, - "Kind": 3 - }, - { - "EndIndex": 142002, - "Kind": 3 - }, - { - "EndIndex": 142020, - "Kind": 3 - }, - { - "EndIndex": 142062, - "Kind": 3 - }, - { - "EndIndex": 142388, - "Kind": 3 - }, - { - "EndIndex": 142410, - "Kind": 3 - }, - { - "EndIndex": 142416, - "Kind": 3 - }, - { - "EndIndex": 142418, - "Kind": 3 - }, - { - "EndIndex": 142459, - "Kind": 3 - }, - { - "EndIndex": 142495, - "Kind": 3 - }, - { - "EndIndex": 142530, - "Kind": 3 - }, - { - "EndIndex": 142549, - "Kind": 3 - }, - { - "EndIndex": 142591, - "Kind": 3 - }, - { - "EndIndex": 142631, - "Kind": 3 - }, - { - "EndIndex": 142645, - "Kind": 3 - }, - { - "EndIndex": 142651, - "Kind": 3 - }, - { - "EndIndex": 142669, - "Kind": 3 - }, - { - "EndIndex": 142702, - "Kind": 3 - }, - { - "EndIndex": 142853, - "Kind": 3 - }, - { - "EndIndex": 142874, - "Kind": 3 - }, - { - "EndIndex": 142880, - "Kind": 3 - }, - { - "EndIndex": 142898, - "Kind": 3 - }, - { - "EndIndex": 142940, - "Kind": 3 - }, - { - "EndIndex": 143266, - "Kind": 3 - }, - { - "EndIndex": 143288, - "Kind": 3 - }, - { - "EndIndex": 143294, - "Kind": 3 - }, - { - "EndIndex": 143296, - "Kind": 3 - }, - { - "EndIndex": 143327, - "Kind": 3 - }, - { - "EndIndex": 143364, - "Kind": 3 - }, - { - "EndIndex": 143393, - "Kind": 3 - }, - { - "EndIndex": 143412, - "Kind": 3 - }, - { - "EndIndex": 143454, - "Kind": 3 - }, - { - "EndIndex": 143495, - "Kind": 3 - }, - { - "EndIndex": 143509, - "Kind": 3 - }, - { - "EndIndex": 143515, - "Kind": 3 - }, - { - "EndIndex": 143533, - "Kind": 3 - }, - { - "EndIndex": 143566, - "Kind": 3 - }, - { - "EndIndex": 143717, - "Kind": 3 - }, - { - "EndIndex": 143738, - "Kind": 3 - }, - { - "EndIndex": 143744, - "Kind": 3 - }, - { - "EndIndex": 143762, - "Kind": 3 - }, - { - "EndIndex": 143804, - "Kind": 3 - }, - { - "EndIndex": 144130, - "Kind": 3 - }, - { - "EndIndex": 144152, - "Kind": 3 - }, - { - "EndIndex": 144158, - "Kind": 3 - }, - { - "EndIndex": 144160, - "Kind": 3 - }, - { - "EndIndex": 144191, - "Kind": 3 - }, - { - "EndIndex": 144213, - "Kind": 3 - }, - { - "EndIndex": 144242, - "Kind": 3 - }, - { - "EndIndex": 144261, - "Kind": 3 - }, - { - "EndIndex": 144303, - "Kind": 3 - }, - { - "EndIndex": 144329, - "Kind": 3 - }, - { - "EndIndex": 144343, - "Kind": 3 - }, - { - "EndIndex": 144349, - "Kind": 3 - }, - { - "EndIndex": 144367, - "Kind": 3 - }, - { - "EndIndex": 144400, - "Kind": 3 - }, - { - "EndIndex": 144551, - "Kind": 3 - }, - { - "EndIndex": 144572, - "Kind": 3 - }, - { - "EndIndex": 144578, - "Kind": 3 - }, - { - "EndIndex": 144596, - "Kind": 3 - }, - { - "EndIndex": 144638, - "Kind": 3 - }, - { - "EndIndex": 144964, - "Kind": 3 - }, - { - "EndIndex": 144986, - "Kind": 3 - }, - { - "EndIndex": 144992, - "Kind": 3 - }, - { - "EndIndex": 144994, - "Kind": 3 - }, - { - "EndIndex": 145035, - "Kind": 3 - }, - { - "EndIndex": 145060, - "Kind": 3 - }, - { - "EndIndex": 145097, - "Kind": 3 - }, - { - "EndIndex": 145116, - "Kind": 3 - }, - { - "EndIndex": 145158, - "Kind": 3 - }, - { - "EndIndex": 145187, - "Kind": 3 - }, - { - "EndIndex": 145201, - "Kind": 3 - }, - { - "EndIndex": 145207, - "Kind": 3 - }, - { - "EndIndex": 145225, - "Kind": 3 - }, - { - "EndIndex": 145258, - "Kind": 3 - }, - { - "EndIndex": 145409, - "Kind": 3 - }, - { - "EndIndex": 145430, - "Kind": 3 - }, - { - "EndIndex": 145436, - "Kind": 3 - }, - { - "EndIndex": 145454, - "Kind": 3 - }, - { - "EndIndex": 145496, - "Kind": 3 - }, - { - "EndIndex": 145822, - "Kind": 3 - }, - { - "EndIndex": 145844, - "Kind": 3 - }, - { - "EndIndex": 145850, - "Kind": 3 - }, - { - "EndIndex": 145852, - "Kind": 3 - }, - { - "EndIndex": 145881, - "Kind": 3 - }, - { - "EndIndex": 145913, - "Kind": 3 - }, - { - "EndIndex": 145940, - "Kind": 3 - }, - { - "EndIndex": 145959, - "Kind": 3 - }, - { - "EndIndex": 146001, - "Kind": 3 - }, - { - "EndIndex": 146037, - "Kind": 3 - }, - { - "EndIndex": 146051, - "Kind": 3 - }, - { - "EndIndex": 146057, - "Kind": 3 - }, - { - "EndIndex": 146075, - "Kind": 3 - }, - { - "EndIndex": 146108, - "Kind": 3 - }, - { - "EndIndex": 146259, - "Kind": 3 - }, - { - "EndIndex": 146280, - "Kind": 3 - }, - { - "EndIndex": 146286, - "Kind": 3 - }, - { - "EndIndex": 146304, - "Kind": 3 - }, - { - "EndIndex": 146346, - "Kind": 3 - }, - { - "EndIndex": 146672, - "Kind": 3 - }, - { - "EndIndex": 146694, - "Kind": 3 - }, - { - "EndIndex": 146700, - "Kind": 3 - }, - { - "EndIndex": 146702, - "Kind": 3 - }, - { - "EndIndex": 146738, - "Kind": 3 - }, - { - "EndIndex": 146782, - "Kind": 3 - }, - { - "EndIndex": 146818, - "Kind": 3 - }, - { - "EndIndex": 146837, - "Kind": 3 - }, - { - "EndIndex": 146879, - "Kind": 3 - }, - { - "EndIndex": 146927, - "Kind": 3 - }, - { - "EndIndex": 146941, - "Kind": 3 - }, - { - "EndIndex": 146947, - "Kind": 3 - }, - { - "EndIndex": 146965, - "Kind": 3 - }, - { - "EndIndex": 146998, - "Kind": 3 - }, - { - "EndIndex": 147149, - "Kind": 3 - }, - { - "EndIndex": 147170, - "Kind": 3 - }, - { - "EndIndex": 147176, - "Kind": 3 - }, - { - "EndIndex": 147194, - "Kind": 3 - }, - { - "EndIndex": 147236, - "Kind": 3 - }, - { - "EndIndex": 147562, - "Kind": 3 - }, - { - "EndIndex": 147584, - "Kind": 3 - }, - { - "EndIndex": 147590, - "Kind": 3 - }, - { - "EndIndex": 147592, - "Kind": 3 - }, - { - "EndIndex": 147631, - "Kind": 3 - }, - { - "EndIndex": 147673, - "Kind": 3 - }, - { - "EndIndex": 147728, - "Kind": 3 - }, - { - "EndIndex": 147765, - "Kind": 3 - }, - { - "EndIndex": 147784, - "Kind": 3 - }, - { - "EndIndex": 147826, - "Kind": 3 - }, - { - "EndIndex": 147885, - "Kind": 3 - }, - { - "EndIndex": 147899, - "Kind": 3 - }, - { - "EndIndex": 147905, - "Kind": 3 - }, - { - "EndIndex": 147923, - "Kind": 3 - }, - { - "EndIndex": 147956, - "Kind": 3 - }, - { - "EndIndex": 148107, - "Kind": 3 - }, - { - "EndIndex": 148128, - "Kind": 3 - }, - { - "EndIndex": 148134, - "Kind": 3 - }, - { - "EndIndex": 148152, - "Kind": 3 - }, - { - "EndIndex": 148194, - "Kind": 3 - }, - { - "EndIndex": 148520, - "Kind": 3 - }, - { - "EndIndex": 148542, - "Kind": 3 - }, - { - "EndIndex": 148548, - "Kind": 3 - }, - { - "EndIndex": 148550, - "Kind": 3 - }, - { - "EndIndex": 148577, - "Kind": 3 - }, - { - "EndIndex": 148619, - "Kind": 3 - }, - { - "EndIndex": 148644, - "Kind": 3 - }, - { - "EndIndex": 148663, - "Kind": 3 - }, - { - "EndIndex": 148705, - "Kind": 3 - }, - { - "EndIndex": 148751, - "Kind": 3 - }, - { - "EndIndex": 148765, - "Kind": 3 - }, - { - "EndIndex": 148771, - "Kind": 3 - }, - { - "EndIndex": 148789, - "Kind": 3 - }, - { - "EndIndex": 148822, - "Kind": 3 - }, - { - "EndIndex": 148973, - "Kind": 3 - }, - { - "EndIndex": 148994, - "Kind": 3 - }, - { - "EndIndex": 149000, - "Kind": 3 - }, - { - "EndIndex": 149027, - "Kind": 3 - }, - { - "EndIndex": 149057, - "Kind": 3 - }, - { - "EndIndex": 149063, - "Kind": 3 - }, - { - "EndIndex": 149087, - "Kind": 3 - }, - { - "EndIndex": 149116, - "Kind": 3 - }, - { - "EndIndex": 149135, - "Kind": 3 - }, - { - "EndIndex": 149141, - "Kind": 3 - }, - { - "EndIndex": 149159, - "Kind": 3 - }, - { - "EndIndex": 149201, - "Kind": 3 - }, - { - "EndIndex": 149527, - "Kind": 3 - }, - { - "EndIndex": 149549, - "Kind": 3 - }, - { - "EndIndex": 149555, - "Kind": 3 - }, - { - "EndIndex": 149570, - "Kind": 3 - }, - { - "EndIndex": 149605, - "Kind": 3 - }, - { - "EndIndex": 149619, - "Kind": 3 - }, - { - "EndIndex": 149625, - "Kind": 3 - }, - { - "EndIndex": 149640, - "Kind": 3 - }, - { - "EndIndex": 149662, - "Kind": 3 - }, - { - "EndIndex": 149694, - "Kind": 3 - }, - { - "EndIndex": 149708, - "Kind": 3 - }, - { - "EndIndex": 149714, - "Kind": 3 - }, - { - "EndIndex": 149729, - "Kind": 3 - }, - { - "EndIndex": 149754, - "Kind": 3 - }, - { - "EndIndex": 149784, - "Kind": 3 - }, - { - "EndIndex": 149798, - "Kind": 3 - }, - { - "EndIndex": 149804, - "Kind": 3 - }, - { - "EndIndex": 149819, - "Kind": 3 - }, - { - "EndIndex": 149845, - "Kind": 3 - }, - { - "EndIndex": 149882, - "Kind": 3 - }, - { - "EndIndex": 149896, - "Kind": 3 - }, - { - "EndIndex": 149902, - "Kind": 3 - }, - { - "EndIndex": 149917, - "Kind": 3 - }, - { - "EndIndex": 149942, - "Kind": 3 - }, - { - "EndIndex": 149972, - "Kind": 3 - }, - { - "EndIndex": 149986, - "Kind": 3 - }, - { - "EndIndex": 149992, - "Kind": 3 - }, - { - "EndIndex": 150007, - "Kind": 3 - }, - { - "EndIndex": 150032, - "Kind": 3 - }, - { - "EndIndex": 150064, - "Kind": 3 - }, - { - "EndIndex": 150078, - "Kind": 3 - }, - { - "EndIndex": 150084, - "Kind": 3 - }, - { - "EndIndex": 150086, - "Kind": 3 - }, - { - "EndIndex": 150125, - "Kind": 3 - }, - { - "EndIndex": 150168, - "Kind": 3 - }, - { - "EndIndex": 150199, - "Kind": 3 - }, - { - "EndIndex": 150218, - "Kind": 3 - }, - { - "EndIndex": 150260, - "Kind": 3 - }, - { - "EndIndex": 150307, - "Kind": 3 - }, - { - "EndIndex": 150321, - "Kind": 3 - }, - { - "EndIndex": 150327, - "Kind": 3 - }, - { - "EndIndex": 150345, - "Kind": 3 - }, - { - "EndIndex": 150378, - "Kind": 3 - }, - { - "EndIndex": 150529, - "Kind": 3 - }, - { - "EndIndex": 150550, - "Kind": 3 - }, - { - "EndIndex": 150556, - "Kind": 3 - }, - { - "EndIndex": 150574, - "Kind": 3 - }, - { - "EndIndex": 150616, - "Kind": 3 - }, - { - "EndIndex": 150942, - "Kind": 3 - }, - { - "EndIndex": 150964, - "Kind": 3 - }, - { - "EndIndex": 150970, - "Kind": 3 - }, - { - "EndIndex": 150972, - "Kind": 3 - }, - { - "EndIndex": 151015, - "Kind": 3 - }, - { - "EndIndex": 151102, - "Kind": 3 - }, - { - "EndIndex": 151145, - "Kind": 3 - }, - { - "EndIndex": 151164, - "Kind": 3 - }, - { - "EndIndex": 151206, - "Kind": 3 - }, - { - "EndIndex": 151297, - "Kind": 3 - }, - { - "EndIndex": 151311, - "Kind": 3 - }, - { - "EndIndex": 151317, - "Kind": 3 - }, - { - "EndIndex": 151335, - "Kind": 3 - }, - { - "EndIndex": 151368, - "Kind": 3 - }, - { - "EndIndex": 151519, - "Kind": 3 - }, - { - "EndIndex": 151540, - "Kind": 3 - }, - { - "EndIndex": 151546, - "Kind": 3 - }, - { - "EndIndex": 151564, - "Kind": 3 - }, - { - "EndIndex": 151606, - "Kind": 3 - }, - { - "EndIndex": 151932, - "Kind": 3 - }, - { - "EndIndex": 151954, - "Kind": 3 - }, - { - "EndIndex": 151960, - "Kind": 3 - }, - { - "EndIndex": 151962, - "Kind": 3 - }, - { - "EndIndex": 151995, - "Kind": 3 - }, - { - "EndIndex": 152026, - "Kind": 3 - }, - { - "EndIndex": 152059, - "Kind": 3 - }, - { - "EndIndex": 152078, - "Kind": 3 - }, - { - "EndIndex": 152120, - "Kind": 3 - }, - { - "EndIndex": 152155, - "Kind": 3 - }, - { - "EndIndex": 152169, - "Kind": 3 - }, - { - "EndIndex": 152175, - "Kind": 3 - }, - { - "EndIndex": 152193, - "Kind": 3 - }, - { - "EndIndex": 152226, - "Kind": 3 - }, - { - "EndIndex": 152377, - "Kind": 3 - }, - { - "EndIndex": 152398, - "Kind": 3 - }, - { - "EndIndex": 152404, - "Kind": 3 - }, - { - "EndIndex": 152422, - "Kind": 3 - }, - { - "EndIndex": 152464, - "Kind": 3 - }, - { - "EndIndex": 152790, - "Kind": 3 - }, - { - "EndIndex": 152812, - "Kind": 3 - }, - { - "EndIndex": 152818, - "Kind": 3 - }, - { - "EndIndex": 152820, - "Kind": 3 - }, - { - "EndIndex": 152856, - "Kind": 3 - }, - { - "EndIndex": 152882, - "Kind": 3 - }, - { - "EndIndex": 152918, - "Kind": 3 - }, - { - "EndIndex": 152937, - "Kind": 3 - }, - { - "EndIndex": 152979, - "Kind": 3 - }, - { - "EndIndex": 153009, - "Kind": 3 - }, - { - "EndIndex": 153023, - "Kind": 3 - }, - { - "EndIndex": 153029, - "Kind": 3 - }, - { - "EndIndex": 153047, - "Kind": 3 - }, - { - "EndIndex": 153080, - "Kind": 3 - }, - { - "EndIndex": 153231, - "Kind": 3 - }, - { - "EndIndex": 153252, - "Kind": 3 - }, - { - "EndIndex": 153258, - "Kind": 3 - }, - { - "EndIndex": 153276, - "Kind": 3 - }, - { - "EndIndex": 153318, - "Kind": 3 - }, - { - "EndIndex": 153644, - "Kind": 3 - }, - { - "EndIndex": 153666, - "Kind": 3 - }, - { - "EndIndex": 153672, - "Kind": 3 - }, - { - "EndIndex": 153674, - "Kind": 3 - }, - { - "EndIndex": 153711, - "Kind": 3 - }, - { - "EndIndex": 153744, - "Kind": 3 - }, - { - "EndIndex": 153776, - "Kind": 3 - }, - { - "EndIndex": 153795, - "Kind": 3 - }, - { - "EndIndex": 153837, - "Kind": 3 - }, - { - "EndIndex": 153874, - "Kind": 3 - }, - { - "EndIndex": 153888, - "Kind": 3 - }, - { - "EndIndex": 153894, - "Kind": 3 - }, - { - "EndIndex": 153912, - "Kind": 3 - }, - { - "EndIndex": 153945, - "Kind": 3 - }, - { - "EndIndex": 154096, - "Kind": 3 - }, - { - "EndIndex": 154117, - "Kind": 3 - }, - { - "EndIndex": 154123, - "Kind": 3 - }, - { - "EndIndex": 154141, - "Kind": 3 - }, - { - "EndIndex": 154183, - "Kind": 3 - }, - { - "EndIndex": 154509, - "Kind": 3 - }, - { - "EndIndex": 154531, - "Kind": 3 - }, - { - "EndIndex": 154537, - "Kind": 3 - }, - { - "EndIndex": 154539, - "Kind": 3 - }, - { - "EndIndex": 154573, - "Kind": 3 - }, - { - "EndIndex": 154626, - "Kind": 3 - }, - { - "EndIndex": 154658, - "Kind": 3 - }, - { - "EndIndex": 154677, - "Kind": 3 - }, - { - "EndIndex": 154719, - "Kind": 3 - }, - { - "EndIndex": 154776, - "Kind": 3 - }, - { - "EndIndex": 154790, - "Kind": 3 - }, - { - "EndIndex": 154796, - "Kind": 3 - }, - { - "EndIndex": 154814, - "Kind": 3 - }, - { - "EndIndex": 154847, - "Kind": 3 - }, - { - "EndIndex": 154998, - "Kind": 3 - }, - { - "EndIndex": 155019, - "Kind": 3 - }, - { - "EndIndex": 155025, - "Kind": 3 - }, - { - "EndIndex": 155043, - "Kind": 3 - }, - { - "EndIndex": 155085, - "Kind": 3 - }, - { - "EndIndex": 155411, - "Kind": 3 - }, - { - "EndIndex": 155433, - "Kind": 3 - }, - { - "EndIndex": 155439, - "Kind": 3 - }, - { - "EndIndex": 155441, - "Kind": 3 - }, - { - "EndIndex": 155474, - "Kind": 3 - }, - { - "EndIndex": 155527, - "Kind": 3 - }, - { - "EndIndex": 155560, - "Kind": 3 - }, - { - "EndIndex": 155579, - "Kind": 3 - }, - { - "EndIndex": 155621, - "Kind": 3 - }, - { - "EndIndex": 155678, - "Kind": 3 - }, - { - "EndIndex": 155692, - "Kind": 3 - }, - { - "EndIndex": 155698, - "Kind": 3 - }, - { - "EndIndex": 155716, - "Kind": 3 - }, - { - "EndIndex": 155749, - "Kind": 3 - }, - { - "EndIndex": 155900, - "Kind": 3 - }, - { - "EndIndex": 155921, - "Kind": 3 - }, - { - "EndIndex": 155927, - "Kind": 3 - }, - { - "EndIndex": 155945, - "Kind": 3 - }, - { - "EndIndex": 155987, - "Kind": 3 - }, - { - "EndIndex": 156313, - "Kind": 3 - }, - { - "EndIndex": 156335, - "Kind": 3 - }, - { - "EndIndex": 156341, - "Kind": 3 - }, - { - "EndIndex": 156343, - "Kind": 3 - }, - { - "EndIndex": 156375, - "Kind": 3 - }, - { - "EndIndex": 156410, - "Kind": 3 - }, - { - "EndIndex": 156440, - "Kind": 3 - }, - { - "EndIndex": 156459, - "Kind": 3 - }, - { - "EndIndex": 156501, - "Kind": 3 - }, - { - "EndIndex": 156540, - "Kind": 3 - }, - { - "EndIndex": 156554, - "Kind": 3 - }, - { - "EndIndex": 156560, - "Kind": 3 - }, - { - "EndIndex": 156578, - "Kind": 3 - }, - { - "EndIndex": 156611, - "Kind": 3 - }, - { - "EndIndex": 156762, - "Kind": 3 - }, - { - "EndIndex": 156783, - "Kind": 3 - }, - { - "EndIndex": 156789, - "Kind": 3 - }, - { - "EndIndex": 156807, - "Kind": 3 - }, - { - "EndIndex": 156849, - "Kind": 3 - }, - { - "EndIndex": 157175, - "Kind": 3 - }, - { - "EndIndex": 157197, - "Kind": 3 - }, - { - "EndIndex": 157203, - "Kind": 3 - }, - { - "EndIndex": 157205, - "Kind": 3 - }, - { - "EndIndex": 157237, - "Kind": 3 - }, - { - "EndIndex": 157300, - "Kind": 3 - }, - { - "EndIndex": 157332, - "Kind": 3 - }, - { - "EndIndex": 157351, - "Kind": 3 - }, - { - "EndIndex": 157393, - "Kind": 3 - }, - { - "EndIndex": 157460, - "Kind": 3 - }, - { - "EndIndex": 157474, - "Kind": 3 - }, - { - "EndIndex": 157480, - "Kind": 3 - }, - { - "EndIndex": 157498, - "Kind": 3 - }, - { - "EndIndex": 157531, - "Kind": 3 - }, - { - "EndIndex": 157682, - "Kind": 3 - }, - { - "EndIndex": 157703, - "Kind": 3 - }, - { - "EndIndex": 157709, - "Kind": 3 - }, - { - "EndIndex": 157727, - "Kind": 3 - }, - { - "EndIndex": 157769, - "Kind": 3 - }, - { - "EndIndex": 158095, - "Kind": 3 - }, - { - "EndIndex": 158117, - "Kind": 3 - }, - { - "EndIndex": 158123, - "Kind": 3 - }, - { - "EndIndex": 158125, - "Kind": 3 - }, - { - "EndIndex": 158163, - "Kind": 3 - }, - { - "EndIndex": 158212, - "Kind": 3 - }, - { - "EndIndex": 158248, - "Kind": 3 - }, - { - "EndIndex": 158267, - "Kind": 3 - }, - { - "EndIndex": 158292, - "Kind": 3 - }, - { - "EndIndex": 158345, - "Kind": 3 - }, - { - "EndIndex": 158359, - "Kind": 3 - }, - { - "EndIndex": 158365, - "Kind": 3 - }, - { - "EndIndex": 158383, - "Kind": 3 - }, - { - "EndIndex": 158416, - "Kind": 3 - }, - { - "EndIndex": 158567, - "Kind": 3 - }, - { - "EndIndex": 158588, - "Kind": 3 - }, - { - "EndIndex": 158594, - "Kind": 3 - }, - { - "EndIndex": 158612, - "Kind": 3 - }, - { - "EndIndex": 158654, - "Kind": 3 - }, - { - "EndIndex": 158980, - "Kind": 3 - }, - { - "EndIndex": 159002, - "Kind": 3 - }, - { - "EndIndex": 159008, - "Kind": 3 - }, - { - "EndIndex": 159010, - "Kind": 3 - }, - { - "EndIndex": 159043, - "Kind": 3 - }, - { - "EndIndex": 159091, - "Kind": 3 - }, - { - "EndIndex": 159122, - "Kind": 3 - }, - { - "EndIndex": 159141, - "Kind": 3 - }, - { - "EndIndex": 159166, - "Kind": 3 - }, - { - "EndIndex": 159218, - "Kind": 3 - }, - { - "EndIndex": 159232, - "Kind": 3 - }, - { - "EndIndex": 159238, - "Kind": 3 - }, - { - "EndIndex": 159256, - "Kind": 3 - }, - { - "EndIndex": 159289, - "Kind": 3 - }, - { - "EndIndex": 159440, - "Kind": 3 - }, - { - "EndIndex": 159461, - "Kind": 3 - }, - { - "EndIndex": 159467, - "Kind": 3 - }, - { - "EndIndex": 159485, - "Kind": 3 - }, - { - "EndIndex": 159527, - "Kind": 3 - }, - { - "EndIndex": 159853, - "Kind": 3 - }, - { - "EndIndex": 159875, - "Kind": 3 - }, - { - "EndIndex": 159881, - "Kind": 3 - }, - { - "EndIndex": 159896, - "Kind": 3 - }, - { - "EndIndex": 159918, - "Kind": 3 - }, - { - "EndIndex": 159952, - "Kind": 3 - }, - { - "EndIndex": 159966, - "Kind": 3 - }, - { - "EndIndex": 159972, - "Kind": 3 - }, - { - "EndIndex": 159974, - "Kind": 3 - }, - { - "EndIndex": 160005, - "Kind": 3 - }, - { - "EndIndex": 160028, - "Kind": 3 - }, - { - "EndIndex": 160057, - "Kind": 3 - }, - { - "EndIndex": 160076, - "Kind": 3 - }, - { - "EndIndex": 160118, - "Kind": 3 - }, - { - "EndIndex": 160145, - "Kind": 3 - }, - { - "EndIndex": 160159, - "Kind": 3 - }, - { - "EndIndex": 160165, - "Kind": 3 - }, - { - "EndIndex": 160183, - "Kind": 3 - }, - { - "EndIndex": 160216, - "Kind": 3 - }, - { - "EndIndex": 160367, - "Kind": 3 - }, - { - "EndIndex": 160388, - "Kind": 3 - }, - { - "EndIndex": 160394, - "Kind": 3 - }, - { - "EndIndex": 160418, - "Kind": 3 - }, - { - "EndIndex": 160447, - "Kind": 3 - }, - { - "EndIndex": 160466, - "Kind": 3 - }, - { - "EndIndex": 160472, - "Kind": 3 - }, - { - "EndIndex": 160490, - "Kind": 3 - }, - { - "EndIndex": 160532, - "Kind": 3 - }, - { - "EndIndex": 160858, - "Kind": 3 - }, - { - "EndIndex": 160880, - "Kind": 3 - }, - { - "EndIndex": 160886, - "Kind": 3 - }, - { - "EndIndex": 160901, - "Kind": 3 - }, - { - "EndIndex": 160926, - "Kind": 3 - }, - { - "EndIndex": 160956, - "Kind": 3 - }, - { - "EndIndex": 160970, - "Kind": 3 - }, - { - "EndIndex": 160976, - "Kind": 3 - }, - { - "EndIndex": 160991, - "Kind": 3 - }, - { - "EndIndex": 161014, - "Kind": 3 - }, - { - "EndIndex": 161042, - "Kind": 3 - }, - { - "EndIndex": 161056, - "Kind": 3 - }, - { - "EndIndex": 161062, - "Kind": 3 - }, - { - "EndIndex": 161077, - "Kind": 3 - }, - { - "EndIndex": 161097, - "Kind": 3 - }, - { - "EndIndex": 161122, - "Kind": 3 - }, - { - "EndIndex": 161136, - "Kind": 3 - }, - { - "EndIndex": 161142, - "Kind": 3 - }, - { - "EndIndex": 161157, - "Kind": 3 - }, - { - "EndIndex": 161180, - "Kind": 3 - }, - { - "EndIndex": 161208, - "Kind": 3 - }, - { - "EndIndex": 161222, - "Kind": 3 - }, - { - "EndIndex": 161228, - "Kind": 3 - }, - { - "EndIndex": 161243, - "Kind": 3 - }, - { - "EndIndex": 161279, - "Kind": 3 - }, - { - "EndIndex": 161320, - "Kind": 3 - }, - { - "EndIndex": 161334, - "Kind": 3 - }, - { - "EndIndex": 161340, - "Kind": 3 - }, - { - "EndIndex": 161355, - "Kind": 3 - }, - { - "EndIndex": 161376, - "Kind": 3 - }, - { - "EndIndex": 161402, - "Kind": 3 - }, - { - "EndIndex": 161416, - "Kind": 3 - }, - { - "EndIndex": 161422, - "Kind": 3 - }, - { - "EndIndex": 161424, - "Kind": 3 - }, - { - "EndIndex": 161455, - "Kind": 3 - }, - { - "EndIndex": 161508, - "Kind": 3 - }, - { - "EndIndex": 161539, - "Kind": 3 - }, - { - "EndIndex": 161558, - "Kind": 3 - }, - { - "EndIndex": 161600, - "Kind": 3 - }, - { - "EndIndex": 161657, - "Kind": 3 - }, - { - "EndIndex": 161671, - "Kind": 3 - }, - { - "EndIndex": 161677, - "Kind": 3 - }, - { - "EndIndex": 161695, - "Kind": 3 - }, - { - "EndIndex": 161728, - "Kind": 3 - }, - { - "EndIndex": 161879, - "Kind": 3 - }, - { - "EndIndex": 161900, - "Kind": 3 - }, - { - "EndIndex": 161906, - "Kind": 3 - }, - { - "EndIndex": 161924, - "Kind": 3 - }, - { - "EndIndex": 161966, - "Kind": 3 - }, - { - "EndIndex": 162292, - "Kind": 3 - }, - { - "EndIndex": 162314, - "Kind": 3 - }, - { - "EndIndex": 162320, - "Kind": 3 - }, - { - "EndIndex": 162322, - "Kind": 3 - }, - { - "EndIndex": 162353, - "Kind": 3 - }, - { - "EndIndex": 162539, - "Kind": 3 - }, - { - "EndIndex": 162568, - "Kind": 3 - }, - { - "EndIndex": 162587, - "Kind": 3 - }, - { - "EndIndex": 162629, - "Kind": 3 - }, - { - "EndIndex": 162819, - "Kind": 3 - }, - { - "EndIndex": 162833, - "Kind": 3 - }, - { - "EndIndex": 162839, - "Kind": 3 - }, - { - "EndIndex": 162857, - "Kind": 3 - }, - { - "EndIndex": 162890, - "Kind": 3 - }, - { - "EndIndex": 163041, - "Kind": 3 - }, - { - "EndIndex": 163062, - "Kind": 3 - }, - { - "EndIndex": 163068, - "Kind": 3 - }, - { - "EndIndex": 163086, - "Kind": 3 - }, - { - "EndIndex": 163128, - "Kind": 3 - }, - { - "EndIndex": 163454, - "Kind": 3 - }, - { - "EndIndex": 163476, - "Kind": 3 - }, - { - "EndIndex": 163482, - "Kind": 3 - }, - { - "EndIndex": 163484, - "Kind": 3 - }, - { - "EndIndex": 163518, - "Kind": 3 - }, - { - "EndIndex": 163563, - "Kind": 3 - }, - { - "EndIndex": 163591, - "Kind": 3 - }, - { - "EndIndex": 163610, - "Kind": 3 - }, - { - "EndIndex": 163652, - "Kind": 3 - }, - { - "EndIndex": 163701, - "Kind": 3 - }, - { - "EndIndex": 163715, - "Kind": 3 - }, - { - "EndIndex": 163721, - "Kind": 3 - }, - { - "EndIndex": 163739, - "Kind": 3 - }, - { - "EndIndex": 163772, - "Kind": 3 - }, - { - "EndIndex": 163923, - "Kind": 3 - }, - { - "EndIndex": 163944, - "Kind": 3 - }, - { - "EndIndex": 163950, - "Kind": 3 - }, - { - "EndIndex": 163968, - "Kind": 3 - }, - { - "EndIndex": 164010, - "Kind": 3 - }, - { - "EndIndex": 164336, - "Kind": 3 - }, - { - "EndIndex": 164358, - "Kind": 3 - }, - { - "EndIndex": 164364, - "Kind": 3 - }, - { - "EndIndex": 164379, - "Kind": 3 - }, - { - "EndIndex": 164400, - "Kind": 3 - }, - { - "EndIndex": 164426, - "Kind": 3 - }, - { - "EndIndex": 164440, - "Kind": 3 - }, - { - "EndIndex": 164446, - "Kind": 3 - }, - { - "EndIndex": 164448, - "Kind": 3 - }, - { - "EndIndex": 164483, - "Kind": 3 - }, - { - "EndIndex": 164527, - "Kind": 3 - }, - { - "EndIndex": 164553, - "Kind": 3 - }, - { - "EndIndex": 164572, - "Kind": 3 - }, - { - "EndIndex": 164614, - "Kind": 3 - }, - { - "EndIndex": 164662, - "Kind": 3 - }, - { - "EndIndex": 164676, - "Kind": 3 - }, - { - "EndIndex": 164682, - "Kind": 3 - }, - { - "EndIndex": 164700, - "Kind": 3 - }, - { - "EndIndex": 164733, - "Kind": 3 - }, - { - "EndIndex": 164884, - "Kind": 3 - }, - { - "EndIndex": 164905, - "Kind": 3 - }, - { - "EndIndex": 164911, - "Kind": 3 - }, - { - "EndIndex": 164929, - "Kind": 3 - }, - { - "EndIndex": 164971, - "Kind": 3 - }, - { - "EndIndex": 165297, - "Kind": 3 - }, - { - "EndIndex": 165319, - "Kind": 3 - }, - { - "EndIndex": 165325, - "Kind": 3 - }, - { - "EndIndex": 165327, - "Kind": 3 - }, - { - "EndIndex": 165357, - "Kind": 3 - }, - { - "EndIndex": 165381, - "Kind": 3 - }, - { - "EndIndex": 165411, - "Kind": 3 - }, - { - "EndIndex": 165430, - "Kind": 3 - }, - { - "EndIndex": 165472, - "Kind": 3 - }, - { - "EndIndex": 165500, - "Kind": 3 - }, - { - "EndIndex": 165514, - "Kind": 3 - }, - { - "EndIndex": 165520, - "Kind": 3 - }, - { - "EndIndex": 165538, - "Kind": 3 - }, - { - "EndIndex": 165571, - "Kind": 3 - }, - { - "EndIndex": 165722, - "Kind": 3 - }, - { - "EndIndex": 165743, - "Kind": 3 - }, - { - "EndIndex": 165749, - "Kind": 3 - }, - { - "EndIndex": 165767, - "Kind": 3 - }, - { - "EndIndex": 165809, - "Kind": 3 - }, - { - "EndIndex": 166135, - "Kind": 3 - }, - { - "EndIndex": 166157, - "Kind": 3 - }, - { - "EndIndex": 166163, - "Kind": 3 - }, - { - "EndIndex": 166165, - "Kind": 3 - }, - { - "EndIndex": 166194, - "Kind": 3 - }, - { - "EndIndex": 166230, - "Kind": 3 - }, - { - "EndIndex": 166257, - "Kind": 3 - }, - { - "EndIndex": 166276, - "Kind": 3 - }, - { - "EndIndex": 166318, - "Kind": 3 - }, - { - "EndIndex": 166358, - "Kind": 3 - }, - { - "EndIndex": 166372, - "Kind": 3 - }, - { - "EndIndex": 166378, - "Kind": 3 - }, - { - "EndIndex": 166396, - "Kind": 3 - }, - { - "EndIndex": 166429, - "Kind": 3 - }, - { - "EndIndex": 166580, - "Kind": 3 - }, - { - "EndIndex": 166601, - "Kind": 3 - }, - { - "EndIndex": 166607, - "Kind": 3 - }, - { - "EndIndex": 166625, - "Kind": 3 - }, - { - "EndIndex": 166667, - "Kind": 3 - }, - { - "EndIndex": 166993, - "Kind": 3 - }, - { - "EndIndex": 167015, - "Kind": 3 - }, - { - "EndIndex": 167021, - "Kind": 3 - }, - { - "EndIndex": 167023, - "Kind": 3 - }, - { - "EndIndex": 167060, - "Kind": 3 - }, - { - "EndIndex": 167115, - "Kind": 3 - }, - { - "EndIndex": 167150, - "Kind": 3 - }, - { - "EndIndex": 167169, - "Kind": 3 - }, - { - "EndIndex": 167211, - "Kind": 3 - }, - { - "EndIndex": 167270, - "Kind": 3 - }, - { - "EndIndex": 167284, - "Kind": 3 - }, - { - "EndIndex": 167290, - "Kind": 3 - }, - { - "EndIndex": 167308, - "Kind": 3 - }, - { - "EndIndex": 167341, - "Kind": 3 - }, - { - "EndIndex": 167492, - "Kind": 3 - }, - { - "EndIndex": 167513, - "Kind": 3 - }, - { - "EndIndex": 167519, - "Kind": 3 - }, - { - "EndIndex": 167537, - "Kind": 3 - }, - { - "EndIndex": 167579, - "Kind": 3 - }, - { - "EndIndex": 167905, - "Kind": 3 - }, - { - "EndIndex": 167927, - "Kind": 3 - }, - { - "EndIndex": 167933, - "Kind": 3 - }, - { - "EndIndex": 167935, - "Kind": 3 - }, - { - "EndIndex": 167976, - "Kind": 3 - }, - { - "EndIndex": 168007, - "Kind": 3 - }, - { - "EndIndex": 168043, - "Kind": 3 - }, - { - "EndIndex": 168062, - "Kind": 3 - }, - { - "EndIndex": 168104, - "Kind": 3 - }, - { - "EndIndex": 168139, - "Kind": 3 - }, - { - "EndIndex": 168153, - "Kind": 3 - }, - { - "EndIndex": 168159, - "Kind": 3 - }, - { - "EndIndex": 168177, - "Kind": 3 - }, - { - "EndIndex": 168210, - "Kind": 3 - }, - { - "EndIndex": 168361, - "Kind": 3 - }, - { - "EndIndex": 168382, - "Kind": 3 - }, - { - "EndIndex": 168388, - "Kind": 3 - }, - { - "EndIndex": 168412, - "Kind": 3 - }, - { - "EndIndex": 168441, - "Kind": 3 - }, - { - "EndIndex": 168460, - "Kind": 3 - }, - { - "EndIndex": 168466, - "Kind": 3 - }, - { - "EndIndex": 168484, - "Kind": 3 - }, - { - "EndIndex": 168526, - "Kind": 3 - }, - { - "EndIndex": 168852, - "Kind": 3 - }, - { - "EndIndex": 168874, - "Kind": 3 - }, - { - "EndIndex": 168880, - "Kind": 3 - }, - { - "EndIndex": 168895, - "Kind": 3 - }, - { - "EndIndex": 168920, - "Kind": 3 - }, - { - "EndIndex": 168950, - "Kind": 3 - }, - { - "EndIndex": 168964, - "Kind": 3 - }, - { - "EndIndex": 168970, - "Kind": 3 - }, - { - "EndIndex": 168985, - "Kind": 3 - }, - { - "EndIndex": 169005, - "Kind": 3 - }, - { - "EndIndex": 169030, - "Kind": 3 - }, - { - "EndIndex": 169044, - "Kind": 3 - }, - { - "EndIndex": 169050, - "Kind": 3 - }, - { - "EndIndex": 169065, - "Kind": 3 - }, - { - "EndIndex": 169088, - "Kind": 3 - }, - { - "EndIndex": 169116, - "Kind": 3 - }, - { - "EndIndex": 169130, - "Kind": 3 - }, - { - "EndIndex": 169136, - "Kind": 3 - }, - { - "EndIndex": 169151, - "Kind": 3 - }, - { - "EndIndex": 169174, - "Kind": 3 - }, - { - "EndIndex": 169202, - "Kind": 3 - }, - { - "EndIndex": 169216, - "Kind": 3 - }, - { - "EndIndex": 169222, - "Kind": 3 - }, - { - "EndIndex": 169237, - "Kind": 3 - }, - { - "EndIndex": 169259, - "Kind": 3 - }, - { - "EndIndex": 169286, - "Kind": 3 - }, - { - "EndIndex": 169300, - "Kind": 3 - }, - { - "EndIndex": 169306, - "Kind": 3 - }, - { - "EndIndex": 169308, - "Kind": 3 - }, - { - "EndIndex": 169349, - "Kind": 3 - }, - { - "EndIndex": 169380, - "Kind": 3 - }, - { - "EndIndex": 169416, - "Kind": 3 - }, - { - "EndIndex": 169435, - "Kind": 3 - }, - { - "EndIndex": 169477, - "Kind": 3 - }, - { - "EndIndex": 169512, - "Kind": 3 - }, - { - "EndIndex": 169526, - "Kind": 3 - }, - { - "EndIndex": 169532, - "Kind": 3 - }, - { - "EndIndex": 169550, - "Kind": 3 - }, - { - "EndIndex": 169583, - "Kind": 3 - }, - { - "EndIndex": 169734, - "Kind": 3 - }, - { - "EndIndex": 169755, - "Kind": 3 - }, - { - "EndIndex": 169761, - "Kind": 3 - }, - { - "EndIndex": 169785, - "Kind": 3 - }, - { - "EndIndex": 169814, - "Kind": 3 - }, - { - "EndIndex": 169833, - "Kind": 3 - }, - { - "EndIndex": 169839, - "Kind": 3 - }, - { - "EndIndex": 169857, - "Kind": 3 - }, - { - "EndIndex": 169899, - "Kind": 3 - }, - { - "EndIndex": 170225, - "Kind": 3 - }, - { - "EndIndex": 170247, - "Kind": 3 - }, - { - "EndIndex": 170253, - "Kind": 3 - }, - { - "EndIndex": 170268, - "Kind": 3 - }, - { - "EndIndex": 170293, - "Kind": 3 - }, - { - "EndIndex": 170323, - "Kind": 3 - }, - { - "EndIndex": 170337, - "Kind": 3 - }, - { - "EndIndex": 170343, - "Kind": 3 - }, - { - "EndIndex": 170358, - "Kind": 3 - }, - { - "EndIndex": 170378, - "Kind": 3 - }, - { - "EndIndex": 170403, - "Kind": 3 - }, - { - "EndIndex": 170417, - "Kind": 3 - }, - { - "EndIndex": 170423, - "Kind": 3 - }, - { - "EndIndex": 170438, - "Kind": 3 - }, - { - "EndIndex": 170461, - "Kind": 3 - }, - { - "EndIndex": 170489, - "Kind": 3 - }, - { - "EndIndex": 170503, - "Kind": 3 - }, - { - "EndIndex": 170509, - "Kind": 3 - }, - { - "EndIndex": 170524, - "Kind": 3 - }, - { - "EndIndex": 170547, - "Kind": 3 - }, - { - "EndIndex": 170575, - "Kind": 3 - }, - { - "EndIndex": 170589, - "Kind": 3 - }, - { - "EndIndex": 170595, - "Kind": 3 - }, - { - "EndIndex": 170610, - "Kind": 3 - }, - { - "EndIndex": 170632, - "Kind": 3 - }, - { - "EndIndex": 170659, - "Kind": 3 - }, - { - "EndIndex": 170673, - "Kind": 3 - }, - { - "EndIndex": 170679, - "Kind": 3 - }, - { - "EndIndex": 170681, - "Kind": 3 - }, - { - "EndIndex": 170714, - "Kind": 3 - }, - { - "EndIndex": 170744, - "Kind": 3 - }, - { - "EndIndex": 170774, - "Kind": 3 - }, - { - "EndIndex": 170793, - "Kind": 3 - }, - { - "EndIndex": 170835, - "Kind": 3 - }, - { - "EndIndex": 170869, - "Kind": 3 - }, - { - "EndIndex": 170883, - "Kind": 3 - }, - { - "EndIndex": 170889, - "Kind": 3 - }, - { - "EndIndex": 170907, - "Kind": 3 - }, - { - "EndIndex": 170940, - "Kind": 3 - }, - { - "EndIndex": 171091, - "Kind": 3 - }, - { - "EndIndex": 171112, - "Kind": 3 - }, - { - "EndIndex": 171118, - "Kind": 3 - }, - { - "EndIndex": 171136, - "Kind": 3 - }, - { - "EndIndex": 171178, - "Kind": 3 - }, - { - "EndIndex": 171504, - "Kind": 3 - }, - { - "EndIndex": 171526, - "Kind": 3 - }, - { - "EndIndex": 171532, - "Kind": 3 - }, - { - "EndIndex": 171534, - "Kind": 3 - }, - { - "EndIndex": 171578, - "Kind": 3 - }, - { - "EndIndex": 171612, - "Kind": 3 - }, - { - "EndIndex": 171651, - "Kind": 3 - }, - { - "EndIndex": 171670, - "Kind": 3 - }, - { - "EndIndex": 171712, - "Kind": 3 - }, - { - "EndIndex": 171750, - "Kind": 3 - }, - { - "EndIndex": 171764, - "Kind": 3 - }, - { - "EndIndex": 171770, - "Kind": 3 - }, - { - "EndIndex": 171788, - "Kind": 3 - }, - { - "EndIndex": 171821, - "Kind": 3 - }, - { - "EndIndex": 171972, - "Kind": 3 - }, - { - "EndIndex": 171993, - "Kind": 3 - }, - { - "EndIndex": 171999, - "Kind": 3 - }, - { - "EndIndex": 172023, - "Kind": 3 - }, - { - "EndIndex": 172052, - "Kind": 3 - }, - { - "EndIndex": 172071, - "Kind": 3 - }, - { - "EndIndex": 172077, - "Kind": 3 - }, - { - "EndIndex": 172095, - "Kind": 3 - }, - { - "EndIndex": 172137, - "Kind": 3 - }, - { - "EndIndex": 172463, - "Kind": 3 - }, - { - "EndIndex": 172485, - "Kind": 3 - }, - { - "EndIndex": 172491, - "Kind": 3 - }, - { - "EndIndex": 172506, - "Kind": 3 - }, - { - "EndIndex": 172531, - "Kind": 3 - }, - { - "EndIndex": 172561, - "Kind": 3 - }, - { - "EndIndex": 172575, - "Kind": 3 - }, - { - "EndIndex": 172581, - "Kind": 3 - }, - { - "EndIndex": 172596, - "Kind": 3 - }, - { - "EndIndex": 172616, - "Kind": 3 - }, - { - "EndIndex": 172641, - "Kind": 3 - }, - { - "EndIndex": 172655, - "Kind": 3 - }, - { - "EndIndex": 172661, - "Kind": 3 - }, - { - "EndIndex": 172676, - "Kind": 3 - }, - { - "EndIndex": 172699, - "Kind": 3 - }, - { - "EndIndex": 172727, - "Kind": 3 - }, - { - "EndIndex": 172741, - "Kind": 3 - }, - { - "EndIndex": 172747, - "Kind": 3 - }, - { - "EndIndex": 172762, - "Kind": 3 - }, - { - "EndIndex": 172785, - "Kind": 3 - }, - { - "EndIndex": 172813, - "Kind": 3 - }, - { - "EndIndex": 172827, - "Kind": 3 - }, - { - "EndIndex": 172833, - "Kind": 3 - }, - { - "EndIndex": 172848, - "Kind": 3 - }, - { - "EndIndex": 172870, - "Kind": 3 - }, - { - "EndIndex": 172897, - "Kind": 3 - }, - { - "EndIndex": 172911, - "Kind": 3 - }, - { - "EndIndex": 172917, - "Kind": 3 - }, - { - "EndIndex": 172919, - "Kind": 3 - }, - { - "EndIndex": 172951, - "Kind": 3 - }, - { - "EndIndex": 173054, - "Kind": 3 - }, - { - "EndIndex": 173086, - "Kind": 3 - }, - { - "EndIndex": 173105, - "Kind": 3 - }, - { - "EndIndex": 173147, - "Kind": 3 - }, - { - "EndIndex": 173254, - "Kind": 3 - }, - { - "EndIndex": 173268, - "Kind": 3 - }, - { - "EndIndex": 173274, - "Kind": 3 - }, - { - "EndIndex": 173292, - "Kind": 3 - }, - { - "EndIndex": 173325, - "Kind": 3 - }, - { - "EndIndex": 173476, - "Kind": 3 - }, - { - "EndIndex": 173497, - "Kind": 3 - }, - { - "EndIndex": 173503, - "Kind": 3 - }, - { - "EndIndex": 173521, - "Kind": 3 - }, - { - "EndIndex": 173563, - "Kind": 3 - }, - { - "EndIndex": 173889, - "Kind": 3 - }, - { - "EndIndex": 173911, - "Kind": 3 - }, - { - "EndIndex": 173917, - "Kind": 3 - }, - { - "EndIndex": 173919, - "Kind": 3 - }, - { - "EndIndex": 173948, - "Kind": 3 - }, - { - "EndIndex": 174003, - "Kind": 3 - }, - { - "EndIndex": 174032, - "Kind": 3 - }, - { - "EndIndex": 174051, - "Kind": 3 - }, - { - "EndIndex": 174093, - "Kind": 3 - }, - { - "EndIndex": 174152, - "Kind": 3 - }, - { - "EndIndex": 174166, - "Kind": 3 - }, - { - "EndIndex": 174172, - "Kind": 3 - }, - { - "EndIndex": 174190, - "Kind": 3 - }, - { - "EndIndex": 174223, - "Kind": 3 - }, - { - "EndIndex": 174374, - "Kind": 3 - }, - { - "EndIndex": 174395, - "Kind": 3 - }, - { - "EndIndex": 174401, - "Kind": 3 - }, - { - "EndIndex": 174419, - "Kind": 3 - }, - { - "EndIndex": 174461, - "Kind": 3 - }, - { - "EndIndex": 174787, - "Kind": 3 - }, - { - "EndIndex": 174809, - "Kind": 3 - }, - { - "EndIndex": 174815, - "Kind": 3 - }, - { - "EndIndex": 174817, - "Kind": 3 - }, - { - "EndIndex": 174847, - "Kind": 3 - }, - { - "EndIndex": 174902, - "Kind": 3 - }, - { - "EndIndex": 174930, - "Kind": 3 - }, - { - "EndIndex": 174949, - "Kind": 3 - }, - { - "EndIndex": 174989, - "Kind": 3 - }, - { - "EndIndex": 175048, - "Kind": 3 - }, - { - "EndIndex": 175062, - "Kind": 3 - }, - { - "EndIndex": 175068, - "Kind": 3 - }, - { - "EndIndex": 175086, - "Kind": 3 - }, - { - "EndIndex": 175119, - "Kind": 3 - }, - { - "EndIndex": 175270, - "Kind": 3 - }, - { - "EndIndex": 175291, - "Kind": 3 - }, - { - "EndIndex": 175297, - "Kind": 3 - }, - { - "EndIndex": 175315, - "Kind": 3 - }, - { - "EndIndex": 175357, - "Kind": 3 - }, - { - "EndIndex": 175683, - "Kind": 3 - }, - { - "EndIndex": 175705, - "Kind": 3 - }, - { - "EndIndex": 175711, - "Kind": 3 - }, - { - "EndIndex": 175713, - "Kind": 3 - }, - { - "EndIndex": 175740, - "Kind": 3 - }, - { - "EndIndex": 175782, - "Kind": 3 - }, - { - "EndIndex": 175807, - "Kind": 3 - }, - { - "EndIndex": 175826, - "Kind": 3 - }, - { - "EndIndex": 175868, - "Kind": 3 - }, - { - "EndIndex": 175914, - "Kind": 3 - }, - { - "EndIndex": 175928, - "Kind": 3 - }, - { - "EndIndex": 175934, - "Kind": 3 - }, - { - "EndIndex": 175952, - "Kind": 3 - }, - { - "EndIndex": 175985, - "Kind": 3 - }, - { - "EndIndex": 176136, - "Kind": 3 - }, - { - "EndIndex": 176157, - "Kind": 3 - }, - { - "EndIndex": 176163, - "Kind": 3 - }, - { - "EndIndex": 176181, - "Kind": 3 - }, - { - "EndIndex": 176223, - "Kind": 3 - }, - { - "EndIndex": 176549, - "Kind": 3 - }, - { - "EndIndex": 176571, - "Kind": 3 - }, - { - "EndIndex": 176577, - "Kind": 3 - }, - { - "EndIndex": 176579, - "Kind": 3 - }, - { - "EndIndex": 176605, - "Kind": 3 - }, - { - "EndIndex": 176648, - "Kind": 3 - }, - { - "EndIndex": 176715, - "Kind": 3 - }, - { - "EndIndex": 176750, - "Kind": 3 - }, - { - "EndIndex": 176769, - "Kind": 3 - }, - { - "EndIndex": 176811, - "Kind": 3 - }, - { - "EndIndex": 176882, - "Kind": 3 - }, - { - "EndIndex": 176896, - "Kind": 3 - }, - { - "EndIndex": 176902, - "Kind": 3 - }, - { - "EndIndex": 176920, - "Kind": 3 - }, - { - "EndIndex": 176953, - "Kind": 3 - }, - { - "EndIndex": 177104, - "Kind": 3 - }, - { - "EndIndex": 177125, - "Kind": 3 - }, - { - "EndIndex": 177131, - "Kind": 3 - }, - { - "EndIndex": 177149, - "Kind": 3 - }, - { - "EndIndex": 177191, - "Kind": 3 - }, - { - "EndIndex": 177517, - "Kind": 3 - }, - { - "EndIndex": 177539, - "Kind": 3 - }, - { - "EndIndex": 177545, - "Kind": 3 - }, - { - "EndIndex": 177547, - "Kind": 3 - }, - { - "EndIndex": 177613, - "Kind": 3 - }, - { - "EndIndex": 177746, - "Kind": 3 - }, - { - "EndIndex": 177756, - "Kind": 3 - }, - { - "EndIndex": 177758, - "Kind": 3 - }, - { - "EndIndex": 177900, - "Kind": 3 - }, - { - "EndIndex": 177972, - "Kind": 3 - }, - { - "EndIndex": 178868, - "Kind": 3 - }, - { - "EndIndex": 178878, - "Kind": 3 - }, - { - "EndIndex": 178880, - "Kind": 3 - }, - { - "EndIndex": 178903, - "Kind": 3 - }, - { - "EndIndex": 178921, - "Kind": 3 - }, - { - "EndIndex": 178934, - "Kind": 3 - }, - { - "EndIndex": 178984, - "Kind": 3 - }, - { - "EndIndex": 178994, - "Kind": 3 - }, - { - "EndIndex": 178996, - "Kind": 3 - }, - { - "EndIndex": 179016, - "Kind": 3 - }, - { - "EndIndex": 179130, - "Kind": 3 - }, - { - "EndIndex": 179148, - "Kind": 3 - }, - { - "EndIndex": 179150, - "Kind": 3 - }, - { - "EndIndex": 179170, - "Kind": 3 - }, - { - "EndIndex": 179278, - "Kind": 3 - }, - { - "EndIndex": 179296, - "Kind": 3 - }, - { - "EndIndex": 179298, - "Kind": 3 - }, - { - "EndIndex": 179315, - "Kind": 3 - }, - { - "EndIndex": 179635, - "Kind": 3 - }, - { - "EndIndex": 179650, - "Kind": 3 - }, - { - "EndIndex": 179652, - "Kind": 3 - }, - { - "EndIndex": 179670, - "Kind": 3 - }, - { - "EndIndex": 179779, - "Kind": 3 - }, - { - "EndIndex": 179794, - "Kind": 3 - }, - { - "EndIndex": 179796, - "Kind": 3 - }, - { - "EndIndex": 179827, - "Kind": 3 - }, - { - "EndIndex": 180020, - "Kind": 3 - }, - { - "EndIndex": 180030, - "Kind": 3 - }, - { - "EndIndex": 180032, - "Kind": 3 - }, - { - "EndIndex": 180058, - "Kind": 3 - }, - { - "EndIndex": 180589, - "Kind": 3 - }, - { - "EndIndex": 180620, - "Kind": 3 - }, - { - "EndIndex": 180650, - "Kind": 3 - }, - { - "EndIndex": 180678, - "Kind": 3 - }, - { - "EndIndex": 180684, - "Kind": 3 - }, - { - "EndIndex": 180710, - "Kind": 3 - }, - { - "EndIndex": 180792, - "Kind": 3 - }, - { - "EndIndex": 180810, - "Kind": 3 - }, - { - "EndIndex": 180816, - "Kind": 3 - }, - { - "EndIndex": 180843, - "Kind": 3 - }, - { - "EndIndex": 180877, - "Kind": 3 - }, - { - "EndIndex": 180908, - "Kind": 3 - }, - { - "EndIndex": 180930, - "Kind": 3 - }, - { - "EndIndex": 180936, - "Kind": 3 - }, - { - "EndIndex": 180969, - "Kind": 3 - }, - { - "EndIndex": 180998, - "Kind": 3 - }, - { - "EndIndex": 181019, - "Kind": 3 - }, - { - "EndIndex": 181025, - "Kind": 3 - }, - { - "EndIndex": 181055, - "Kind": 3 - }, - { - "EndIndex": 181086, - "Kind": 3 - }, - { - "EndIndex": 181108, - "Kind": 3 - }, - { - "EndIndex": 181114, - "Kind": 3 - }, - { - "EndIndex": 181144, - "Kind": 3 - }, - { - "EndIndex": 181175, - "Kind": 3 - }, - { - "EndIndex": 181197, - "Kind": 3 - }, - { - "EndIndex": 181203, - "Kind": 3 - }, - { - "EndIndex": 181242, - "Kind": 3 - }, - { - "EndIndex": 181281, - "Kind": 3 - }, - { - "EndIndex": 181295, - "Kind": 3 - }, - { - "EndIndex": 181301, - "Kind": 3 - }, - { - "EndIndex": 181334, - "Kind": 3 - }, - { - "EndIndex": 181363, - "Kind": 3 - }, - { - "EndIndex": 181377, - "Kind": 3 - }, - { - "EndIndex": 181383, - "Kind": 3 - }, - { - "EndIndex": 181413, - "Kind": 3 - }, - { - "EndIndex": 181443, - "Kind": 3 - }, - { - "EndIndex": 181465, - "Kind": 3 - }, - { - "EndIndex": 181471, - "Kind": 3 - }, - { - "EndIndex": 181492, - "Kind": 3 - }, - { - "EndIndex": 181524, - "Kind": 3 - }, - { - "EndIndex": 181558, - "Kind": 3 - }, - { - "EndIndex": 181579, - "Kind": 3 - }, - { - "EndIndex": 181585, - "Kind": 3 - }, - { - "EndIndex": 181617, - "Kind": 3 - }, - { - "EndIndex": 181651, - "Kind": 3 - }, - { - "EndIndex": 181672, - "Kind": 3 - }, - { - "EndIndex": 181678, - "Kind": 3 - }, - { - "EndIndex": 181734, - "Kind": 3 - }, - { - "EndIndex": 182269, - "Kind": 3 - }, - { - "EndIndex": 182283, - "Kind": 3 - }, - { - "EndIndex": 182289, - "Kind": 3 - }, - { - "EndIndex": 182307, - "Kind": 3 - }, - { - "EndIndex": 182340, - "Kind": 3 - }, - { - "EndIndex": 182491, - "Kind": 3 - }, - { - "EndIndex": 182512, - "Kind": 3 - }, - { - "EndIndex": 182518, - "Kind": 3 - }, - { - "EndIndex": 182543, - "Kind": 3 - }, - { - "EndIndex": 182576, - "Kind": 3 - }, - { - "EndIndex": 182604, - "Kind": 3 - }, - { - "EndIndex": 182610, - "Kind": 3 - }, - { - "EndIndex": 182640, - "Kind": 3 - }, - { - "EndIndex": 182671, - "Kind": 3 - }, - { - "EndIndex": 182693, - "Kind": 3 - }, - { - "EndIndex": 182699, - "Kind": 3 - }, - { - "EndIndex": 182723, - "Kind": 3 - }, - { - "EndIndex": 182752, - "Kind": 3 - }, - { - "EndIndex": 182770, - "Kind": 3 - }, - { - "EndIndex": 182776, - "Kind": 3 - }, - { - "EndIndex": 182806, - "Kind": 3 - }, - { - "EndIndex": 182836, - "Kind": 3 - }, - { - "EndIndex": 182858, - "Kind": 3 - }, - { - "EndIndex": 182864, - "Kind": 3 - }, - { - "EndIndex": 182895, - "Kind": 3 - }, - { - "EndIndex": 182925, - "Kind": 3 - }, - { - "EndIndex": 182953, - "Kind": 3 - }, - { - "EndIndex": 182959, - "Kind": 3 - }, - { - "EndIndex": 182990, - "Kind": 3 - }, - { - "EndIndex": 183020, - "Kind": 3 - }, - { - "EndIndex": 183048, - "Kind": 3 - }, - { - "EndIndex": 183054, - "Kind": 3 - }, - { - "EndIndex": 183084, - "Kind": 3 - }, - { - "EndIndex": 183115, - "Kind": 3 - }, - { - "EndIndex": 183137, - "Kind": 3 - }, - { - "EndIndex": 183143, - "Kind": 3 - }, - { - "EndIndex": 183170, - "Kind": 3 - }, - { - "EndIndex": 183220, - "Kind": 3 - }, - { - "EndIndex": 183250, - "Kind": 3 - }, - { - "EndIndex": 183256, - "Kind": 3 - }, - { - "EndIndex": 183293, - "Kind": 3 - }, - { - "EndIndex": 183343, - "Kind": 3 - }, - { - "EndIndex": 183373, - "Kind": 3 - }, - { - "EndIndex": 183379, - "Kind": 3 - }, - { - "EndIndex": 183404, - "Kind": 3 - }, - { - "EndIndex": 183434, - "Kind": 3 - }, - { - "EndIndex": 183453, - "Kind": 3 - }, - { - "EndIndex": 183459, - "Kind": 3 - }, - { - "EndIndex": 183491, - "Kind": 3 - }, - { - "EndIndex": 183521, - "Kind": 3 - }, - { - "EndIndex": 183549, - "Kind": 3 - }, - { - "EndIndex": 183555, - "Kind": 3 - }, - { - "EndIndex": 183587, - "Kind": 3 - }, - { - "EndIndex": 183617, - "Kind": 3 - }, - { - "EndIndex": 183645, - "Kind": 3 - }, - { - "EndIndex": 183651, - "Kind": 3 - }, - { - "EndIndex": 183691, - "Kind": 3 - }, - { - "EndIndex": 183726, - "Kind": 3 - }, - { - "EndIndex": 183747, - "Kind": 3 - }, - { - "EndIndex": 183753, - "Kind": 3 - }, - { - "EndIndex": 183780, - "Kind": 3 - }, - { - "EndIndex": 183853, - "Kind": 3 - }, - { - "EndIndex": 183871, - "Kind": 3 - }, - { - "EndIndex": 183877, - "Kind": 3 - }, - { - "EndIndex": 183901, - "Kind": 3 - }, - { - "EndIndex": 183930, - "Kind": 3 - }, - { - "EndIndex": 183949, - "Kind": 3 - }, - { - "EndIndex": 183955, - "Kind": 3 - }, - { - "EndIndex": 183973, - "Kind": 3 - }, - { - "EndIndex": 184015, - "Kind": 3 - }, - { - "EndIndex": 184341, - "Kind": 3 - }, - { - "EndIndex": 184363, - "Kind": 3 - }, - { - "EndIndex": 184369, - "Kind": 3 - }, - { - "EndIndex": 184398, - "Kind": 3 - }, - { - "EndIndex": 184499, - "Kind": 3 - }, - { - "EndIndex": 184513, - "Kind": 3 - }, - { - "EndIndex": 184519, - "Kind": 3 - }, - { - "EndIndex": 184546, - "Kind": 3 - }, - { - "EndIndex": 184684, - "Kind": 3 - }, - { - "EndIndex": 184712, - "Kind": 3 - }, - { - "EndIndex": 184718, - "Kind": 3 - }, - { - "EndIndex": 184741, - "Kind": 3 - }, - { - "EndIndex": 184918, - "Kind": 3 - }, - { - "EndIndex": 184946, - "Kind": 3 - }, - { - "EndIndex": 184952, - "Kind": 3 - }, - { - "EndIndex": 184974, - "Kind": 3 - }, - { - "EndIndex": 185022, - "Kind": 3 - }, - { - "EndIndex": 185043, - "Kind": 3 - }, - { - "EndIndex": 185049, - "Kind": 3 - }, - { - "EndIndex": 185070, - "Kind": 3 - }, - { - "EndIndex": 185101, - "Kind": 3 - }, - { - "EndIndex": 185129, - "Kind": 3 - }, - { - "EndIndex": 185135, - "Kind": 3 - }, - { - "EndIndex": 185160, - "Kind": 3 - }, - { - "EndIndex": 185374, - "Kind": 3 - }, - { - "EndIndex": 185392, - "Kind": 3 - }, - { - "EndIndex": 185398, - "Kind": 3 - }, - { - "EndIndex": 185439, - "Kind": 3 - }, - { - "EndIndex": 185916, - "Kind": 3 - }, - { - "EndIndex": 185930, - "Kind": 3 - }, - { - "EndIndex": 185936, - "Kind": 3 - }, - { - "EndIndex": 185986, - "Kind": 3 - }, - { - "EndIndex": 186266, - "Kind": 3 - }, - { - "EndIndex": 186288, - "Kind": 3 - }, - { - "EndIndex": 186294, - "Kind": 3 - }, - { - "EndIndex": 186332, - "Kind": 3 - }, - { - "EndIndex": 186519, - "Kind": 3 - }, - { - "EndIndex": 186547, - "Kind": 3 - }, - { - "EndIndex": 186553, - "Kind": 3 - }, - { - "EndIndex": 186594, - "Kind": 3 - }, - { - "EndIndex": 186745, - "Kind": 3 - }, - { - "EndIndex": 186759, - "Kind": 3 - }, - { - "EndIndex": 186765, - "Kind": 3 - }, - { - "EndIndex": 186808, - "Kind": 3 - }, - { - "EndIndex": 187064, - "Kind": 3 - }, - { - "EndIndex": 187082, - "Kind": 3 - }, - { - "EndIndex": 187088, - "Kind": 3 - }, - { - "EndIndex": 187106, - "Kind": 3 - }, - { - "EndIndex": 187143, - "Kind": 3 - }, - { - "EndIndex": 187340, - "Kind": 3 - }, - { - "EndIndex": 187354, - "Kind": 3 - }, - { - "EndIndex": 187360, - "Kind": 3 - }, - { - "EndIndex": 187380, - "Kind": 3 - }, - { - "EndIndex": 187535, - "Kind": 3 - }, - { - "EndIndex": 187554, - "Kind": 3 - }, - { - "EndIndex": 187560, - "Kind": 3 - }, - { - "EndIndex": 187585, - "Kind": 3 - }, - { - "EndIndex": 187872, - "Kind": 3 - }, - { - "EndIndex": 187890, - "Kind": 3 - }, - { - "EndIndex": 187896, - "Kind": 3 - }, - { - "EndIndex": 187932, - "Kind": 3 - }, - { - "EndIndex": 188106, - "Kind": 3 - }, - { - "EndIndex": 188120, - "Kind": 3 - }, - { - "EndIndex": 188126, - "Kind": 3 - }, - { - "EndIndex": 188150, - "Kind": 3 - }, - { - "EndIndex": 188296, - "Kind": 3 - }, - { - "EndIndex": 188318, - "Kind": 3 - }, - { - "EndIndex": 188324, - "Kind": 3 - }, - { - "EndIndex": 188348, - "Kind": 3 - }, - { - "EndIndex": 188492, - "Kind": 3 - }, - { - "EndIndex": 188514, - "Kind": 3 - }, - { - "EndIndex": 188520, - "Kind": 3 - }, - { - "EndIndex": 188544, - "Kind": 3 - }, - { - "EndIndex": 188656, - "Kind": 3 - }, - { - "EndIndex": 188677, - "Kind": 3 - }, - { - "EndIndex": 188683, - "Kind": 3 - }, - { - "EndIndex": 188707, - "Kind": 3 - }, - { - "EndIndex": 188847, - "Kind": 3 - }, - { - "EndIndex": 188869, - "Kind": 3 - }, - { - "EndIndex": 188875, - "Kind": 3 - }, - { - "EndIndex": 188899, - "Kind": 3 - }, - { - "EndIndex": 189054, - "Kind": 3 - }, - { - "EndIndex": 189076, - "Kind": 3 - }, - { - "EndIndex": 189082, - "Kind": 3 - }, - { - "EndIndex": 189106, - "Kind": 3 - }, - { - "EndIndex": 189250, - "Kind": 3 - }, - { - "EndIndex": 189272, - "Kind": 3 - }, - { - "EndIndex": 189278, - "Kind": 3 - }, - { - "EndIndex": 189302, - "Kind": 3 - }, - { - "EndIndex": 189548, - "Kind": 3 - }, - { - "EndIndex": 189570, - "Kind": 3 - }, - { - "EndIndex": 189576, - "Kind": 3 - }, - { - "EndIndex": 189600, - "Kind": 3 - }, - { - "EndIndex": 189755, - "Kind": 3 - }, - { - "EndIndex": 189777, - "Kind": 3 - }, - { - "EndIndex": 189783, - "Kind": 3 - }, - { - "EndIndex": 189823, - "Kind": 3 - }, - { - "EndIndex": 190012, - "Kind": 3 - }, - { - "EndIndex": 190026, - "Kind": 3 - }, - { - "EndIndex": 190032, - "Kind": 3 - }, - { - "EndIndex": 190054, - "Kind": 3 - }, - { - "EndIndex": 190235, - "Kind": 3 - }, - { - "EndIndex": 190263, - "Kind": 3 - }, - { - "EndIndex": 190269, - "Kind": 3 - }, - { - "EndIndex": 190291, - "Kind": 3 - }, - { - "EndIndex": 190397, - "Kind": 3 - }, - { - "EndIndex": 190425, - "Kind": 3 - }, - { - "EndIndex": 190431, - "Kind": 3 - }, - { - "EndIndex": 190461, - "Kind": 3 - }, - { - "EndIndex": 190590, - "Kind": 3 - }, - { - "EndIndex": 190618, - "Kind": 3 - }, - { - "EndIndex": 190624, - "Kind": 3 - }, - { - "EndIndex": 190642, - "Kind": 3 - }, - { - "EndIndex": 190676, - "Kind": 3 - }, - { - "EndIndex": 190935, - "Kind": 3 - }, - { - "EndIndex": 190949, - "Kind": 3 - }, - { - "EndIndex": 190955, - "Kind": 3 - }, - { - "EndIndex": 190986, - "Kind": 3 - }, - { - "EndIndex": 191423, - "Kind": 3 - }, - { - "EndIndex": 191479, - "Kind": 3 - }, - { - "EndIndex": 191485, - "Kind": 3 - }, - { - "EndIndex": 191512, - "Kind": 3 - }, - { - "EndIndex": 191734, - "Kind": 3 - }, - { - "EndIndex": 191748, - "Kind": 3 - }, - { - "EndIndex": 191754, - "Kind": 3 - }, - { - "EndIndex": 191784, - "Kind": 3 - }, - { - "EndIndex": 191889, - "Kind": 3 - }, - { - "EndIndex": 191910, - "Kind": 3 - }, - { - "EndIndex": 191916, - "Kind": 3 - }, - { - "EndIndex": 191957, - "Kind": 3 - }, - { - "EndIndex": 192246, - "Kind": 3 - }, - { - "EndIndex": 192274, - "Kind": 3 - }, - { - "EndIndex": 192280, - "Kind": 3 - }, - { - "EndIndex": 192304, - "Kind": 3 - }, - { - "EndIndex": 192362, - "Kind": 3 - }, - { - "EndIndex": 192376, - "Kind": 3 - }, - { - "EndIndex": 192382, - "Kind": 3 - }, - { - "EndIndex": 192426, - "Kind": 3 - }, - { - "EndIndex": 192684, - "Kind": 3 - }, - { - "EndIndex": 192702, - "Kind": 3 - }, - { - "EndIndex": 192708, - "Kind": 3 - }, - { - "EndIndex": 192753, - "Kind": 3 - }, - { - "EndIndex": 193041, - "Kind": 3 - }, - { - "EndIndex": 193059, - "Kind": 3 - }, - { - "EndIndex": 193065, - "Kind": 3 - }, - { - "EndIndex": 193087, - "Kind": 3 - }, - { - "EndIndex": 193268, - "Kind": 3 - }, - { - "EndIndex": 193296, - "Kind": 3 - }, - { - "EndIndex": 193302, - "Kind": 3 - }, - { - "EndIndex": 193334, - "Kind": 3 - }, - { - "EndIndex": 193793, - "Kind": 3 - }, - { - "EndIndex": 193849, - "Kind": 3 - }, - { - "EndIndex": 193855, - "Kind": 3 - }, - { - "EndIndex": 193893, - "Kind": 3 - }, - { - "EndIndex": 194358, - "Kind": 3 - }, - { - "EndIndex": 194388, - "Kind": 3 - }, - { - "EndIndex": 194394, - "Kind": 3 - }, - { - "EndIndex": 194424, - "Kind": 3 - }, - { - "EndIndex": 194555, - "Kind": 3 - }, - { - "EndIndex": 194583, - "Kind": 3 - }, - { - "EndIndex": 194589, - "Kind": 3 - }, - { - "EndIndex": 194626, - "Kind": 3 - }, - { - "EndIndex": 195007, - "Kind": 3 - }, - { - "EndIndex": 195037, - "Kind": 3 - }, - { - "EndIndex": 195043, - "Kind": 3 - }, - { - "EndIndex": 195080, - "Kind": 3 - }, - { - "EndIndex": 195255, - "Kind": 3 - }, - { - "EndIndex": 195280, - "Kind": 3 - }, - { - "EndIndex": 195286, - "Kind": 3 - }, - { - "EndIndex": 195338, - "Kind": 3 - }, - { - "EndIndex": 195622, - "Kind": 3 - }, - { - "EndIndex": 195644, - "Kind": 3 - }, - { - "EndIndex": 195650, - "Kind": 3 - }, - { - "EndIndex": 195679, - "Kind": 3 - }, - { - "EndIndex": 195834, - "Kind": 3 - }, - { - "EndIndex": 195862, - "Kind": 3 - }, - { - "EndIndex": 195868, - "Kind": 3 - }, - { - "EndIndex": 195893, - "Kind": 3 - }, - { - "EndIndex": 196030, - "Kind": 3 - }, - { - "EndIndex": 196058, - "Kind": 3 - }, - { - "EndIndex": 196064, - "Kind": 3 - }, - { - "EndIndex": 196086, - "Kind": 3 - }, - { - "EndIndex": 196255, - "Kind": 3 - }, - { - "EndIndex": 196283, - "Kind": 3 - }, - { - "EndIndex": 196289, - "Kind": 3 - }, - { - "EndIndex": 196330, - "Kind": 3 - }, - { - "EndIndex": 196640, - "Kind": 3 - }, - { - "EndIndex": 196654, - "Kind": 3 - }, - { - "EndIndex": 196660, - "Kind": 3 - }, - { - "EndIndex": 196682, - "Kind": 3 - }, - { - "EndIndex": 196788, - "Kind": 3 - }, - { - "EndIndex": 196816, - "Kind": 3 - }, - { - "EndIndex": 196822, - "Kind": 3 - }, - { - "EndIndex": 196851, - "Kind": 3 - }, - { - "EndIndex": 197004, - "Kind": 3 - }, - { - "EndIndex": 197032, - "Kind": 3 - }, - { - "EndIndex": 197038, - "Kind": 3 - }, - { - "EndIndex": 197040, - "Kind": 3 - }, - { - "EndIndex": 197060, - "Kind": 3 - }, - { - "EndIndex": 197226, - "Kind": 3 - }, - { - "EndIndex": 197244, - "Kind": 3 - }, - { - "EndIndex": 197246, - "Kind": 3 - }, - { - "EndIndex": 197259, - "Kind": 3 - }, - { - "EndIndex": 197343, - "Kind": 3 - }, - { - "EndIndex": 197358, - "Kind": 3 - }, - { - "EndIndex": 197360, - "Kind": 3 - }, - { - "EndIndex": 197429, - "Kind": 3 - }, - { - "EndIndex": 198151, - "Kind": 3 - }, - { - "EndIndex": 198161, - "Kind": 3 - }, - { - "EndIndex": 198163, - "Kind": 3 - }, - { - "EndIndex": 198185, - "Kind": 3 - }, - { - "EndIndex": 198304, - "Kind": 3 - }, - { - "EndIndex": 198314, - "Kind": 3 - }, - { - "EndIndex": 198316, - "Kind": 3 - }, - { - "EndIndex": 198336, - "Kind": 3 - }, - { - "EndIndex": 198455, - "Kind": 3 - }, - { - "EndIndex": 198465, - "Kind": 3 - }, - { - "EndIndex": 198467, - "Kind": 3 - }, - { - "EndIndex": 198492, - "Kind": 3 - }, - { - "EndIndex": 198598, - "Kind": 3 - }, - { - "EndIndex": 198608, - "Kind": 3 - }, - { - "EndIndex": 198610, - "Kind": 3 - }, - { - "EndIndex": 198633, - "Kind": 3 - }, - { - "EndIndex": 199275, - "Kind": 3 - }, - { - "EndIndex": 199294, - "Kind": 3 - }, - { - "EndIndex": 199296, - "Kind": 3 - }, - { - "EndIndex": 199315, - "Kind": 3 - }, - { - "EndIndex": 199382, - "Kind": 3 - }, - { - "EndIndex": 199401, - "Kind": 3 - }, - { - "EndIndex": 199403, - "Kind": 3 - }, - { - "EndIndex": 199429, - "Kind": 3 - }, - { - "EndIndex": 199756, - "Kind": 3 - }, - { - "EndIndex": 199783, - "Kind": 3 - }, - { - "EndIndex": 199822, - "Kind": 3 - }, - { - "EndIndex": 199861, - "Kind": 3 - }, - { - "EndIndex": 199875, - "Kind": 3 - }, - { - "EndIndex": 199881, - "Kind": 3 - }, - { - "EndIndex": 199923, - "Kind": 3 - }, - { - "EndIndex": 200254, - "Kind": 3 - }, - { - "EndIndex": 200268, - "Kind": 3 - }, - { - "EndIndex": 200274, - "Kind": 3 - }, - { - "EndIndex": 200292, - "Kind": 3 - }, - { - "EndIndex": 200325, - "Kind": 3 - }, - { - "EndIndex": 200476, - "Kind": 3 - }, - { - "EndIndex": 200497, - "Kind": 3 - }, - { - "EndIndex": 200503, - "Kind": 3 - }, - { - "EndIndex": 200528, - "Kind": 3 - }, - { - "EndIndex": 200561, - "Kind": 3 - }, - { - "EndIndex": 200589, - "Kind": 3 - }, - { - "EndIndex": 200595, - "Kind": 3 - }, - { - "EndIndex": 200620, - "Kind": 3 - }, - { - "EndIndex": 200653, - "Kind": 3 - }, - { - "EndIndex": 200667, - "Kind": 3 - }, - { - "EndIndex": 200673, - "Kind": 3 - }, - { - "EndIndex": 200700, - "Kind": 3 - }, - { - "EndIndex": 200750, - "Kind": 3 - }, - { - "EndIndex": 200780, - "Kind": 3 - }, - { - "EndIndex": 200786, - "Kind": 3 - }, - { - "EndIndex": 200804, - "Kind": 3 - }, - { - "EndIndex": 200846, - "Kind": 3 - }, - { - "EndIndex": 201172, - "Kind": 3 - }, - { - "EndIndex": 201194, - "Kind": 3 - }, - { - "EndIndex": 201200, - "Kind": 3 - }, - { - "EndIndex": 201202, - "Kind": 3 - }, - { - "EndIndex": 201238, - "Kind": 3 - }, - { - "EndIndex": 201578, - "Kind": 3 - }, - { - "EndIndex": 201588, - "Kind": 3 - }, - { - "EndIndex": 201590, - "Kind": 3 - }, - { - "EndIndex": 201626, - "Kind": 3 - }, - { - "EndIndex": 201975, - "Kind": 3 - }, - { - "EndIndex": 201985, - "Kind": 3 - }, - { - "EndIndex": 201987, - "Kind": 3 - }, - { - "EndIndex": 202010, - "Kind": 3 - }, - { - "EndIndex": 202020, - "Kind": 3 - }, - { - "EndIndex": 202022, - "Kind": 3 - }, - { - "EndIndex": 202045, - "Kind": 3 - }, - { - "EndIndex": 202248, - "Kind": 3 - }, - { - "EndIndex": 202272, - "Kind": 3 - }, - { - "EndIndex": 202311, - "Kind": 3 - }, - { - "EndIndex": 202350, - "Kind": 3 - }, - { - "EndIndex": 202364, - "Kind": 3 - }, - { - "EndIndex": 202370, - "Kind": 3 - }, - { - "EndIndex": 202421, - "Kind": 3 - }, - { - "EndIndex": 202628, - "Kind": 3 - }, - { - "EndIndex": 202642, - "Kind": 3 - }, - { - "EndIndex": 202648, - "Kind": 3 - }, - { - "EndIndex": 202666, - "Kind": 3 - }, - { - "EndIndex": 202699, - "Kind": 3 - }, - { - "EndIndex": 202850, - "Kind": 3 - }, - { - "EndIndex": 202871, - "Kind": 3 - }, - { - "EndIndex": 202877, - "Kind": 3 - }, - { - "EndIndex": 202902, - "Kind": 3 - }, - { - "EndIndex": 202935, - "Kind": 3 - }, - { - "EndIndex": 202960, - "Kind": 3 - }, - { - "EndIndex": 202966, - "Kind": 3 - }, - { - "EndIndex": 202991, - "Kind": 3 - }, - { - "EndIndex": 203024, - "Kind": 3 - }, - { - "EndIndex": 203038, - "Kind": 3 - }, - { - "EndIndex": 203044, - "Kind": 3 - }, - { - "EndIndex": 203071, - "Kind": 3 - }, - { - "EndIndex": 203121, - "Kind": 3 - }, - { - "EndIndex": 203151, - "Kind": 3 - }, - { - "EndIndex": 203157, - "Kind": 3 - }, - { - "EndIndex": 203175, - "Kind": 3 - }, - { - "EndIndex": 203217, - "Kind": 3 - }, - { - "EndIndex": 203543, - "Kind": 3 - }, - { - "EndIndex": 203565, - "Kind": 3 - }, - { - "EndIndex": 203571, - "Kind": 3 - }, - { - "EndIndex": 203573, - "Kind": 3 - }, - { - "EndIndex": 203606, - "Kind": 3 - }, - { - "EndIndex": 203783, - "Kind": 3 - }, - { - "EndIndex": 203798, - "Kind": 3 - }, - { - "EndIndex": 203800, - "Kind": 3 - }, - { - "EndIndex": 203842, - "Kind": 3 - }, - { - "EndIndex": 204104, - "Kind": 3 - }, - { - "EndIndex": 204114, - "Kind": 3 - }, - { - "EndIndex": 204116, - "Kind": 3 - }, - { - "EndIndex": 204132, - "Kind": 3 - }, - { - "EndIndex": 204318, - "Kind": 3 - }, - { - "EndIndex": 204341, - "Kind": 3 - }, - { - "EndIndex": 204343, - "Kind": 3 - }, - { - "EndIndex": 204368, - "Kind": 3 - }, - { - "EndIndex": 204514, - "Kind": 3 - }, - { - "EndIndex": 204532, - "Kind": 3 - }, - { - "EndIndex": 204534, - "Kind": 3 - }, - { - "EndIndex": 204550, - "Kind": 3 - }, - { - "EndIndex": 204713, - "Kind": 3 - }, - { - "EndIndex": 204727, - "Kind": 3 - }, - { - "EndIndex": 204729, - "Kind": 3 - }, - { - "EndIndex": 204761, - "Kind": 3 - }, - { - "EndIndex": 205083, - "Kind": 3 - }, - { - "EndIndex": 205093, - "Kind": 3 - }, - { - "EndIndex": 205095, - "Kind": 3 - }, - { - "EndIndex": 205113, - "Kind": 3 - }, - { - "EndIndex": 205212, - "Kind": 3 - }, - { - "EndIndex": 205227, - "Kind": 3 - }, - { - "EndIndex": 205229, - "Kind": 3 - }, - { - "EndIndex": 205243, - "Kind": 3 - }, - { - "EndIndex": 205403, - "Kind": 3 - }, - { - "EndIndex": 205417, - "Kind": 3 - }, - { - "EndIndex": 205419, - "Kind": 3 - }, - { - "EndIndex": 205439, - "Kind": 3 - }, - { - "EndIndex": 205757, - "Kind": 3 - }, - { - "EndIndex": 205772, - "Kind": 3 - }, - { - "EndIndex": 205774, - "Kind": 3 - }, - { - "EndIndex": 205812, - "Kind": 3 - }, - { - "EndIndex": 206068, - "Kind": 3 - }, - { - "EndIndex": 206078, - "Kind": 3 - }, - { - "EndIndex": 206080, - "Kind": 3 - }, - { - "EndIndex": 206118, - "Kind": 3 - }, - { - "EndIndex": 206372, - "Kind": 3 - }, - { - "EndIndex": 206382, - "Kind": 3 - }, - { - "EndIndex": 206384, - "Kind": 3 - }, - { - "EndIndex": 206415, - "Kind": 3 - }, - { - "EndIndex": 206679, - "Kind": 3 - }, - { - "EndIndex": 206689, - "Kind": 3 - }, - { - "EndIndex": 206691, - "Kind": 3 - }, - { - "EndIndex": 206706, - "Kind": 3 - }, - { - "EndIndex": 206756, - "Kind": 3 - }, - { - "EndIndex": 206770, - "Kind": 3 - }, - { - "EndIndex": 206772, - "Kind": 3 - }, - { - "EndIndex": 206792, - "Kind": 3 - }, - { - "EndIndex": 206911, - "Kind": 3 - }, - { - "EndIndex": 206921, - "Kind": 3 - }, - { - "EndIndex": 206923, - "Kind": 3 - }, - { - "EndIndex": 206938, - "Kind": 3 - }, - { - "EndIndex": 207214, - "Kind": 3 - }, - { - "EndIndex": 207237, - "Kind": 3 - }, - { - "EndIndex": 207239, - "Kind": 3 - }, - { - "EndIndex": 207259, - "Kind": 3 - }, - { - "EndIndex": 207443, - "Kind": 3 - }, - { - "EndIndex": 207464, - "Kind": 3 - }, - { - "EndIndex": 207503, - "Kind": 3 - }, - { - "EndIndex": 207542, - "Kind": 3 - }, - { - "EndIndex": 207556, - "Kind": 3 - }, - { - "EndIndex": 207562, - "Kind": 3 - }, - { - "EndIndex": 207605, - "Kind": 3 - }, - { - "EndIndex": 207793, - "Kind": 3 - }, - { - "EndIndex": 207807, - "Kind": 3 - }, - { - "EndIndex": 207813, - "Kind": 3 - }, - { - "EndIndex": 207831, - "Kind": 3 - }, - { - "EndIndex": 207864, - "Kind": 3 - }, - { - "EndIndex": 208015, - "Kind": 3 - }, - { - "EndIndex": 208036, - "Kind": 3 - }, - { - "EndIndex": 208042, - "Kind": 3 - }, - { - "EndIndex": 208067, - "Kind": 3 - }, - { - "EndIndex": 208100, - "Kind": 3 - }, - { - "EndIndex": 208122, - "Kind": 3 - }, - { - "EndIndex": 208128, - "Kind": 3 - }, - { - "EndIndex": 208153, - "Kind": 3 - }, - { - "EndIndex": 208186, - "Kind": 3 - }, - { - "EndIndex": 208200, - "Kind": 3 - }, - { - "EndIndex": 208206, - "Kind": 3 - }, - { - "EndIndex": 208233, - "Kind": 3 - }, - { - "EndIndex": 208283, - "Kind": 3 - }, - { - "EndIndex": 208313, - "Kind": 3 - }, - { - "EndIndex": 208319, - "Kind": 3 - }, - { - "EndIndex": 208337, - "Kind": 3 - }, - { - "EndIndex": 208379, - "Kind": 3 - }, - { - "EndIndex": 208705, - "Kind": 3 - }, - { - "EndIndex": 208727, - "Kind": 3 - }, - { - "EndIndex": 208733, - "Kind": 3 - }, - { - "EndIndex": 208735, - "Kind": 3 - }, - { - "EndIndex": 208781, - "Kind": 3 - }, - { - "EndIndex": 209107, - "Kind": 3 - }, - { - "EndIndex": 209117, - "Kind": 3 - }, - { - "EndIndex": 209119, - "Kind": 3 - }, - { - "EndIndex": 209146, - "Kind": 3 - }, - { - "EndIndex": 209219, - "Kind": 3 - }, - { - "EndIndex": 209247, - "Kind": 3 - }, - { - "EndIndex": 209280, - "Kind": 3 - }, - { - "EndIndex": 209309, - "Kind": 3 - }, - { - "EndIndex": 209330, - "Kind": 3 - }, - { - "EndIndex": 209336, - "Kind": 3 - }, - { - "EndIndex": 209362, - "Kind": 3 - }, - { - "EndIndex": 209383, - "Kind": 3 - }, - { - "EndIndex": 209389, - "Kind": 3 - }, - { - "EndIndex": 209419, - "Kind": 3 - }, - { - "EndIndex": 209450, - "Kind": 3 - }, - { - "EndIndex": 209472, - "Kind": 3 - }, - { - "EndIndex": 209478, - "Kind": 3 - }, - { - "EndIndex": 209503, - "Kind": 3 - }, - { - "EndIndex": 209517, - "Kind": 3 - }, - { - "EndIndex": 209523, - "Kind": 3 - }, - { - "EndIndex": 209553, - "Kind": 3 - }, - { - "EndIndex": 209584, - "Kind": 3 - }, - { - "EndIndex": 209606, - "Kind": 3 - }, - { - "EndIndex": 209612, - "Kind": 3 - }, - { - "EndIndex": 209651, - "Kind": 3 - }, - { - "EndIndex": 209690, - "Kind": 3 - }, - { - "EndIndex": 209704, - "Kind": 3 - }, - { - "EndIndex": 209710, - "Kind": 3 - }, - { - "EndIndex": 209743, - "Kind": 3 - }, - { - "EndIndex": 209772, - "Kind": 3 - }, - { - "EndIndex": 209786, - "Kind": 3 - }, - { - "EndIndex": 209792, - "Kind": 3 - }, - { - "EndIndex": 209822, - "Kind": 3 - }, - { - "EndIndex": 209852, - "Kind": 3 - }, - { - "EndIndex": 209874, - "Kind": 3 - }, - { - "EndIndex": 209880, - "Kind": 3 - }, - { - "EndIndex": 209905, - "Kind": 3 - }, - { - "EndIndex": 209935, - "Kind": 3 - }, - { - "EndIndex": 209953, - "Kind": 3 - }, - { - "EndIndex": 209959, - "Kind": 3 - }, - { - "EndIndex": 210001, - "Kind": 3 - }, - { - "EndIndex": 210078, - "Kind": 3 - }, - { - "EndIndex": 210092, - "Kind": 3 - }, - { - "EndIndex": 210098, - "Kind": 3 - }, - { - "EndIndex": 210116, - "Kind": 3 - }, - { - "EndIndex": 210149, - "Kind": 3 - }, - { - "EndIndex": 210300, - "Kind": 3 - }, - { - "EndIndex": 210321, - "Kind": 3 - }, - { - "EndIndex": 210327, - "Kind": 3 - }, - { - "EndIndex": 210357, - "Kind": 3 - }, - { - "EndIndex": 210388, - "Kind": 3 - }, - { - "EndIndex": 210410, - "Kind": 3 - }, - { - "EndIndex": 210416, - "Kind": 3 - }, - { - "EndIndex": 210440, - "Kind": 3 - }, - { - "EndIndex": 210469, - "Kind": 3 - }, - { - "EndIndex": 210487, - "Kind": 3 - }, - { - "EndIndex": 210493, - "Kind": 3 - }, - { - "EndIndex": 210523, - "Kind": 3 - }, - { - "EndIndex": 210553, - "Kind": 3 - }, - { - "EndIndex": 210575, - "Kind": 3 - }, - { - "EndIndex": 210581, - "Kind": 3 - }, - { - "EndIndex": 210611, - "Kind": 3 - }, - { - "EndIndex": 210642, - "Kind": 3 - }, - { - "EndIndex": 210664, - "Kind": 3 - }, - { - "EndIndex": 210670, - "Kind": 3 - }, - { - "EndIndex": 210695, - "Kind": 3 - }, - { - "EndIndex": 210725, - "Kind": 3 - }, - { - "EndIndex": 210744, - "Kind": 3 - }, - { - "EndIndex": 210750, - "Kind": 3 - }, - { - "EndIndex": 210790, - "Kind": 3 - }, - { - "EndIndex": 210825, - "Kind": 3 - }, - { - "EndIndex": 210846, - "Kind": 3 - }, - { - "EndIndex": 210852, - "Kind": 3 - }, - { - "EndIndex": 210870, - "Kind": 3 - }, - { - "EndIndex": 210912, - "Kind": 3 - }, - { - "EndIndex": 211238, - "Kind": 3 - }, - { - "EndIndex": 211260, - "Kind": 3 - }, - { - "EndIndex": 211266, - "Kind": 3 - }, - { - "EndIndex": 211281, - "Kind": 3 - }, - { - "EndIndex": 211310, - "Kind": 3 - }, - { - "EndIndex": 211375, - "Kind": 3 - }, - { - "EndIndex": 211389, - "Kind": 3 - }, - { - "EndIndex": 211395, - "Kind": 3 - }, - { - "EndIndex": 211424, - "Kind": 3 - }, - { - "EndIndex": 211479, - "Kind": 3 - }, - { - "EndIndex": 211493, - "Kind": 3 - }, - { - "EndIndex": 211499, - "Kind": 3 - }, - { - "EndIndex": 211514, - "Kind": 3 - }, - { - "EndIndex": 211541, - "Kind": 3 - }, - { - "EndIndex": 211604, - "Kind": 3 - }, - { - "EndIndex": 211618, - "Kind": 3 - }, - { - "EndIndex": 211624, - "Kind": 3 - }, - { - "EndIndex": 211639, - "Kind": 3 - }, - { - "EndIndex": 211668, - "Kind": 3 - }, - { - "EndIndex": 211739, - "Kind": 3 - }, - { - "EndIndex": 211753, - "Kind": 3 - }, - { - "EndIndex": 211759, - "Kind": 3 - }, - { - "EndIndex": 211774, - "Kind": 3 - }, - { - "EndIndex": 211797, - "Kind": 3 - }, - { - "EndIndex": 211896, - "Kind": 3 - }, - { - "EndIndex": 211915, - "Kind": 3 - }, - { - "EndIndex": 211921, - "Kind": 3 - }, - { - "EndIndex": 211941, - "Kind": 3 - }, - { - "EndIndex": 212018, - "Kind": 3 - }, - { - "EndIndex": 212037, - "Kind": 3 - }, - { - "EndIndex": 212043, - "Kind": 3 - }, - { - "EndIndex": 212058, - "Kind": 3 - }, - { - "EndIndex": 212083, - "Kind": 3 - }, - { - "EndIndex": 212147, - "Kind": 3 - }, - { - "EndIndex": 212161, - "Kind": 3 - }, - { - "EndIndex": 212167, - "Kind": 3 - }, - { - "EndIndex": 212182, - "Kind": 3 - }, - { - "EndIndex": 212205, - "Kind": 3 - }, - { - "EndIndex": 212304, - "Kind": 3 - }, - { - "EndIndex": 212318, - "Kind": 3 - }, - { - "EndIndex": 212324, - "Kind": 3 - }, - { - "EndIndex": 212339, - "Kind": 3 - }, - { - "EndIndex": 212360, - "Kind": 3 - }, - { - "EndIndex": 212467, - "Kind": 3 - }, - { - "EndIndex": 212481, - "Kind": 3 - }, - { - "EndIndex": 212487, - "Kind": 3 - }, - { - "EndIndex": 212502, - "Kind": 3 - }, - { - "EndIndex": 212522, - "Kind": 3 - }, - { - "EndIndex": 212574, - "Kind": 3 - }, - { - "EndIndex": 212588, - "Kind": 3 - }, - { - "EndIndex": 212594, - "Kind": 3 - }, - { - "EndIndex": 212609, - "Kind": 3 - }, - { - "EndIndex": 212634, - "Kind": 3 - }, - { - "EndIndex": 212696, - "Kind": 3 - }, - { - "EndIndex": 212710, - "Kind": 3 - }, - { - "EndIndex": 212716, - "Kind": 3 - }, - { - "EndIndex": 212740, - "Kind": 3 - }, - { - "EndIndex": 212815, - "Kind": 3 - }, - { - "EndIndex": 212829, - "Kind": 3 - }, - { - "EndIndex": 212835, - "Kind": 3 - }, - { - "EndIndex": 212850, - "Kind": 3 - }, - { - "EndIndex": 212872, - "Kind": 3 - }, - { - "EndIndex": 212968, - "Kind": 3 - }, - { - "EndIndex": 212982, - "Kind": 3 - }, - { - "EndIndex": 212988, - "Kind": 3 - }, - { - "EndIndex": 213003, - "Kind": 3 - }, - { - "EndIndex": 213027, - "Kind": 3 - }, - { - "EndIndex": 213146, - "Kind": 3 - }, - { - "EndIndex": 213160, - "Kind": 3 - }, - { - "EndIndex": 213166, - "Kind": 3 - }, - { - "EndIndex": 213181, - "Kind": 3 - }, - { - "EndIndex": 213208, - "Kind": 3 - }, - { - "EndIndex": 213277, - "Kind": 3 - }, - { - "EndIndex": 213291, - "Kind": 3 - }, - { - "EndIndex": 213297, - "Kind": 3 - }, - { - "EndIndex": 213321, - "Kind": 3 - }, - { - "EndIndex": 213380, - "Kind": 3 - }, - { - "EndIndex": 213394, - "Kind": 3 - }, - { - "EndIndex": 213400, - "Kind": 3 - }, - { - "EndIndex": 213423, - "Kind": 3 - }, - { - "EndIndex": 213487, - "Kind": 3 - }, - { - "EndIndex": 213501, - "Kind": 3 - }, - { - "EndIndex": 213507, - "Kind": 3 - }, - { - "EndIndex": 213509, - "Kind": 3 - }, - { - "EndIndex": 213555, - "Kind": 3 - }, - { - "EndIndex": 213883, - "Kind": 3 - }, - { - "EndIndex": 213893, - "Kind": 3 - }, - { - "EndIndex": 213895, - "Kind": 3 - }, - { - "EndIndex": 213930, - "Kind": 3 - }, - { - "EndIndex": 214107, - "Kind": 3 - }, - { - "EndIndex": 214117, - "Kind": 3 - }, - { - "EndIndex": 214119, - "Kind": 3 - }, - { - "EndIndex": 214137, - "Kind": 3 - }, - { - "EndIndex": 214229, - "Kind": 3 - }, - { - "EndIndex": 214244, - "Kind": 3 - }, - { - "EndIndex": 214246, - "Kind": 3 - }, - { - "EndIndex": 214324, - "Kind": 3 - }, - { - "EndIndex": 220772, - "Kind": 3 - }, - { - "EndIndex": 220782, - "Kind": 3 - }, - { - "EndIndex": 220784, - "Kind": 3 - }, - { - "EndIndex": 220797, - "Kind": 3 - }, - { - "EndIndex": 220862, - "Kind": 3 - }, - { - "EndIndex": 220872, - "Kind": 3 - }, - { - "EndIndex": 220874, - "Kind": 3 - }, - { - "EndIndex": 220893, - "Kind": 3 - }, - { - "EndIndex": 221092, - "Kind": 3 - }, - { - "EndIndex": 221102, - "Kind": 3 - }, - { - "EndIndex": 221104, - "Kind": 3 - }, - { - "EndIndex": 221118, - "Kind": 3 - }, - { - "EndIndex": 221526, - "Kind": 3 - }, - { - "EndIndex": 221536, - "Kind": 3 - }, - { - "EndIndex": 221538, - "Kind": 3 - }, - { - "EndIndex": 221561, - "Kind": 3 - }, - { - "EndIndex": 221571, - "Kind": 3 - }, - { - "EndIndex": 221573, - "Kind": 3 - }, - { - "EndIndex": 221595, - "Kind": 3 - }, - { - "EndIndex": 222030, - "Kind": 3 - }, - { - "EndIndex": 222055, - "Kind": 3 - }, - { - "EndIndex": 222076, - "Kind": 3 - }, - { - "EndIndex": 222098, - "Kind": 3 - }, - { - "EndIndex": 222104, - "Kind": 3 - }, - { - "EndIndex": 222127, - "Kind": 3 - }, - { - "EndIndex": 222161, - "Kind": 3 - }, - { - "EndIndex": 222192, - "Kind": 3 - }, - { - "EndIndex": 222214, - "Kind": 3 - }, - { - "EndIndex": 222220, - "Kind": 3 - }, - { - "EndIndex": 222250, - "Kind": 3 - }, - { - "EndIndex": 222281, - "Kind": 3 - }, - { - "EndIndex": 222303, - "Kind": 3 - }, - { - "EndIndex": 222309, - "Kind": 3 - }, - { - "EndIndex": 222339, - "Kind": 3 - }, - { - "EndIndex": 222370, - "Kind": 3 - }, - { - "EndIndex": 222392, - "Kind": 3 - }, - { - "EndIndex": 222398, - "Kind": 3 - }, - { - "EndIndex": 222437, - "Kind": 3 - }, - { - "EndIndex": 222476, - "Kind": 3 - }, - { - "EndIndex": 222490, - "Kind": 3 - }, - { - "EndIndex": 222496, - "Kind": 3 - }, - { - "EndIndex": 222529, - "Kind": 3 - }, - { - "EndIndex": 222558, - "Kind": 3 - }, - { - "EndIndex": 222572, - "Kind": 3 - }, - { - "EndIndex": 222578, - "Kind": 3 - }, - { - "EndIndex": 222608, - "Kind": 3 - }, - { - "EndIndex": 222638, - "Kind": 3 - }, - { - "EndIndex": 222660, - "Kind": 3 - }, - { - "EndIndex": 222666, - "Kind": 3 - }, - { - "EndIndex": 222691, - "Kind": 3 - }, - { - "EndIndex": 222721, - "Kind": 3 - }, - { - "EndIndex": 222739, - "Kind": 3 - }, - { - "EndIndex": 222745, - "Kind": 3 - }, - { - "EndIndex": 222794, - "Kind": 3 - }, - { - "EndIndex": 223233, - "Kind": 3 - }, - { - "EndIndex": 223247, - "Kind": 3 - }, - { - "EndIndex": 223253, - "Kind": 3 - }, - { - "EndIndex": 223271, - "Kind": 3 - }, - { - "EndIndex": 223304, - "Kind": 3 - }, - { - "EndIndex": 223455, - "Kind": 3 - }, - { - "EndIndex": 223476, - "Kind": 3 - }, - { - "EndIndex": 223482, - "Kind": 3 - }, - { - "EndIndex": 223507, - "Kind": 3 - }, - { - "EndIndex": 223540, - "Kind": 3 - }, - { - "EndIndex": 223564, - "Kind": 3 - }, - { - "EndIndex": 223570, - "Kind": 3 - }, - { - "EndIndex": 223600, - "Kind": 3 - }, - { - "EndIndex": 223631, - "Kind": 3 - }, - { - "EndIndex": 223653, - "Kind": 3 - }, - { - "EndIndex": 223659, - "Kind": 3 - }, - { - "EndIndex": 223683, - "Kind": 3 - }, - { - "EndIndex": 223712, - "Kind": 3 - }, - { - "EndIndex": 223730, - "Kind": 3 - }, - { - "EndIndex": 223736, - "Kind": 3 - }, - { - "EndIndex": 223766, - "Kind": 3 - }, - { - "EndIndex": 223796, - "Kind": 3 - }, - { - "EndIndex": 223818, - "Kind": 3 - }, - { - "EndIndex": 223824, - "Kind": 3 - }, - { - "EndIndex": 223854, - "Kind": 3 - }, - { - "EndIndex": 223885, - "Kind": 3 - }, - { - "EndIndex": 223907, - "Kind": 3 - }, - { - "EndIndex": 223913, - "Kind": 3 - }, - { - "EndIndex": 223940, - "Kind": 3 - }, - { - "EndIndex": 223970, - "Kind": 3 - }, - { - "EndIndex": 223976, - "Kind": 3 - }, - { - "EndIndex": 224001, - "Kind": 3 - }, - { - "EndIndex": 224031, - "Kind": 3 - }, - { - "EndIndex": 224050, - "Kind": 3 - }, - { - "EndIndex": 224056, - "Kind": 3 - }, - { - "EndIndex": 224085, - "Kind": 3 - }, - { - "EndIndex": 224123, - "Kind": 3 - }, - { - "EndIndex": 224137, - "Kind": 3 - }, - { - "EndIndex": 224143, - "Kind": 3 - }, - { - "EndIndex": 224161, - "Kind": 3 - }, - { - "EndIndex": 224203, - "Kind": 3 - }, - { - "EndIndex": 224529, - "Kind": 3 - }, - { - "EndIndex": 224551, - "Kind": 3 - }, - { - "EndIndex": 224557, - "Kind": 3 - }, - { - "EndIndex": 224582, - "Kind": 3 - }, - { - "EndIndex": 224670, - "Kind": 3 - }, - { - "EndIndex": 224688, - "Kind": 3 - }, - { - "EndIndex": 224694, - "Kind": 3 - }, - { - "EndIndex": 224719, - "Kind": 3 - }, - { - "EndIndex": 224856, - "Kind": 3 - }, - { - "EndIndex": 224874, - "Kind": 3 - }, - { - "EndIndex": 224880, - "Kind": 3 - }, - { - "EndIndex": 224895, - "Kind": 3 - }, - { - "EndIndex": 224917, - "Kind": 3 - }, - { - "EndIndex": 224931, - "Kind": 3 - }, - { - "EndIndex": 224937, - "Kind": 3 - }, - { - "EndIndex": 224952, - "Kind": 3 - }, - { - "EndIndex": 224973, - "Kind": 3 - }, - { - "EndIndex": 224987, - "Kind": 3 - }, - { - "EndIndex": 224993, - "Kind": 3 - }, - { - "EndIndex": 225008, - "Kind": 3 - }, - { - "EndIndex": 225029, - "Kind": 3 - }, - { - "EndIndex": 225043, - "Kind": 3 - }, - { - "EndIndex": 225049, - "Kind": 3 - }, - { - "EndIndex": 225051, - "Kind": 3 - }, - { - "EndIndex": 225067, - "Kind": 3 - }, - { - "EndIndex": 225207, - "Kind": 3 - }, - { - "EndIndex": 225222, - "Kind": 3 - }, - { - "EndIndex": 225224, - "Kind": 3 - }, - { - "EndIndex": 225249, - "Kind": 3 - }, - { - "EndIndex": 225321, - "Kind": 3 - }, - { - "EndIndex": 225347, - "Kind": 3 - }, - { - "EndIndex": 225386, - "Kind": 3 - }, - { - "EndIndex": 225425, - "Kind": 3 - }, - { - "EndIndex": 225439, - "Kind": 3 - }, - { - "EndIndex": 225445, - "Kind": 3 - }, - { - "EndIndex": 225487, - "Kind": 3 - }, - { - "EndIndex": 225563, - "Kind": 3 - }, - { - "EndIndex": 225577, - "Kind": 3 - }, - { - "EndIndex": 225583, - "Kind": 3 - }, - { - "EndIndex": 225601, - "Kind": 3 - }, - { - "EndIndex": 225634, - "Kind": 3 - }, - { - "EndIndex": 225785, - "Kind": 3 - }, - { - "EndIndex": 225806, - "Kind": 3 - }, - { - "EndIndex": 225812, - "Kind": 3 - }, - { - "EndIndex": 225837, - "Kind": 3 - }, - { - "EndIndex": 225870, - "Kind": 3 - }, - { - "EndIndex": 225897, - "Kind": 3 - }, - { - "EndIndex": 225903, - "Kind": 3 - }, - { - "EndIndex": 225935, - "Kind": 3 - }, - { - "EndIndex": 226001, - "Kind": 3 - }, - { - "EndIndex": 226019, - "Kind": 3 - }, - { - "EndIndex": 226025, - "Kind": 3 - }, - { - "EndIndex": 226050, - "Kind": 3 - }, - { - "EndIndex": 226083, - "Kind": 3 - }, - { - "EndIndex": 226097, - "Kind": 3 - }, - { - "EndIndex": 226103, - "Kind": 3 - }, - { - "EndIndex": 226130, - "Kind": 3 - }, - { - "EndIndex": 226180, - "Kind": 3 - }, - { - "EndIndex": 226210, - "Kind": 3 - }, - { - "EndIndex": 226216, - "Kind": 3 - }, - { - "EndIndex": 226252, - "Kind": 3 - }, - { - "EndIndex": 226301, - "Kind": 3 - }, - { - "EndIndex": 226322, - "Kind": 3 - }, - { - "EndIndex": 226328, - "Kind": 3 - }, - { - "EndIndex": 226346, - "Kind": 3 - }, - { - "EndIndex": 226388, - "Kind": 3 - }, - { - "EndIndex": 226714, - "Kind": 3 - }, - { - "EndIndex": 226736, - "Kind": 3 - }, - { - "EndIndex": 226742, - "Kind": 3 - }, - { - "EndIndex": 226744, - "Kind": 3 - }, - { - "EndIndex": 226773, - "Kind": 3 - }, - { - "EndIndex": 226988, - "Kind": 3 - }, - { - "EndIndex": 227004, - "Kind": 3 - }, - { - "EndIndex": 227006, - "Kind": 3 - }, - { - "EndIndex": 227038, - "Kind": 3 - }, - { - "EndIndex": 227165, - "Kind": 3 - }, - { - "EndIndex": 227175, - "Kind": 3 - }, - { - "EndIndex": 227177, - "Kind": 3 - }, - { - "EndIndex": 227199, - "Kind": 3 - }, - { - "EndIndex": 227325, - "Kind": 3 - }, - { - "EndIndex": 227348, - "Kind": 3 - }, - { - "EndIndex": 227378, - "Kind": 3 - }, - { - "EndIndex": 227409, - "Kind": 3 - }, - { - "EndIndex": 227431, - "Kind": 3 - }, - { - "EndIndex": 227437, - "Kind": 3 - }, - { - "EndIndex": 227467, - "Kind": 3 - }, - { - "EndIndex": 227498, - "Kind": 3 - }, - { - "EndIndex": 227520, - "Kind": 3 - }, - { - "EndIndex": 227526, - "Kind": 3 - }, - { - "EndIndex": 227565, - "Kind": 3 - }, - { - "EndIndex": 227604, - "Kind": 3 - }, - { - "EndIndex": 227618, - "Kind": 3 - }, - { - "EndIndex": 227624, - "Kind": 3 - }, - { - "EndIndex": 227654, - "Kind": 3 - }, - { - "EndIndex": 227684, - "Kind": 3 - }, - { - "EndIndex": 227706, - "Kind": 3 - }, - { - "EndIndex": 227712, - "Kind": 3 - }, - { - "EndIndex": 227733, - "Kind": 3 - }, - { - "EndIndex": 227782, - "Kind": 3 - }, - { - "EndIndex": 227912, - "Kind": 3 - }, - { - "EndIndex": 227926, - "Kind": 3 - }, - { - "EndIndex": 227932, - "Kind": 3 - }, - { - "EndIndex": 227950, - "Kind": 3 - }, - { - "EndIndex": 227983, - "Kind": 3 - }, - { - "EndIndex": 228134, - "Kind": 3 - }, - { - "EndIndex": 228155, - "Kind": 3 - }, - { - "EndIndex": 228161, - "Kind": 3 - }, - { - "EndIndex": 228191, - "Kind": 3 - }, - { - "EndIndex": 228222, - "Kind": 3 - }, - { - "EndIndex": 228244, - "Kind": 3 - }, - { - "EndIndex": 228250, - "Kind": 3 - }, - { - "EndIndex": 228280, - "Kind": 3 - }, - { - "EndIndex": 228310, - "Kind": 3 - }, - { - "EndIndex": 228332, - "Kind": 3 - }, - { - "EndIndex": 228338, - "Kind": 3 - }, - { - "EndIndex": 228368, - "Kind": 3 - }, - { - "EndIndex": 228399, - "Kind": 3 - }, - { - "EndIndex": 228421, - "Kind": 3 - }, - { - "EndIndex": 228427, - "Kind": 3 - }, - { - "EndIndex": 228454, - "Kind": 3 - }, - { - "EndIndex": 228504, - "Kind": 3 - }, - { - "EndIndex": 228534, - "Kind": 3 - }, - { - "EndIndex": 228540, - "Kind": 3 - }, - { - "EndIndex": 228565, - "Kind": 3 - }, - { - "EndIndex": 228595, - "Kind": 3 - }, - { - "EndIndex": 228614, - "Kind": 3 - }, - { - "EndIndex": 228620, - "Kind": 3 - }, - { - "EndIndex": 228638, - "Kind": 3 - }, - { - "EndIndex": 228680, - "Kind": 3 - }, - { - "EndIndex": 229006, - "Kind": 3 - }, - { - "EndIndex": 229028, - "Kind": 3 - }, - { - "EndIndex": 229034, - "Kind": 3 - }, - { - "EndIndex": 229058, - "Kind": 3 - }, - { - "EndIndex": 229341, - "Kind": 3 - }, - { - "EndIndex": 229365, - "Kind": 3 - }, - { - "EndIndex": 229371, - "Kind": 3 - }, - { - "EndIndex": 229386, - "Kind": 3 - }, - { - "EndIndex": 229408, - "Kind": 3 - }, - { - "EndIndex": 229422, - "Kind": 3 - }, - { - "EndIndex": 229428, - "Kind": 3 - }, - { - "EndIndex": 229443, - "Kind": 3 - }, - { - "EndIndex": 229464, - "Kind": 3 - }, - { - "EndIndex": 229478, - "Kind": 3 - }, - { - "EndIndex": 229484, - "Kind": 3 - }, - { - "EndIndex": 229499, - "Kind": 3 - }, - { - "EndIndex": 229520, - "Kind": 3 - }, - { - "EndIndex": 229534, - "Kind": 3 - }, - { - "EndIndex": 229540, - "Kind": 3 - }, - { - "EndIndex": 229542, - "Kind": 3 - }, - { - "EndIndex": 229565, - "Kind": 3 - }, - { - "EndIndex": 229795, - "Kind": 3 - }, - { - "EndIndex": 229818, - "Kind": 3 - }, - { - "EndIndex": 229820, - "Kind": 3 - }, - { - "EndIndex": 229847, - "Kind": 3 - }, - { - "EndIndex": 230087, - "Kind": 3 - }, - { - "EndIndex": 230097, - "Kind": 3 - }, - { - "EndIndex": 230099, - "Kind": 3 - }, - { - "EndIndex": 230121, - "Kind": 3 - }, - { - "EndIndex": 230609, - "Kind": 3 - }, - { - "EndIndex": 230632, - "Kind": 3 - }, - { - "EndIndex": 230673, - "Kind": 3 - }, - { - "EndIndex": 230741, - "Kind": 3 - }, - { - "EndIndex": 230765, - "Kind": 3 - }, - { - "EndIndex": 230771, - "Kind": 3 - }, - { - "EndIndex": 230810, - "Kind": 3 - }, - { - "EndIndex": 230849, - "Kind": 3 - }, - { - "EndIndex": 230863, - "Kind": 3 - }, - { - "EndIndex": 230869, - "Kind": 3 - }, - { - "EndIndex": 230907, - "Kind": 3 - }, - { - "EndIndex": 231399, - "Kind": 3 - }, - { - "EndIndex": 231413, - "Kind": 3 - }, - { - "EndIndex": 231419, - "Kind": 3 - }, - { - "EndIndex": 231437, - "Kind": 3 - }, - { - "EndIndex": 231470, - "Kind": 3 - }, - { - "EndIndex": 231621, - "Kind": 3 - }, - { - "EndIndex": 231642, - "Kind": 3 - }, - { - "EndIndex": 231648, - "Kind": 3 - }, - { - "EndIndex": 231673, - "Kind": 3 - }, - { - "EndIndex": 231703, - "Kind": 3 - }, - { - "EndIndex": 231722, - "Kind": 3 - }, - { - "EndIndex": 231728, - "Kind": 3 - }, - { - "EndIndex": 231743, - "Kind": 3 - }, - { - "EndIndex": 231768, - "Kind": 3 - }, - { - "EndIndex": 231822, - "Kind": 3 - }, - { - "EndIndex": 231836, - "Kind": 3 - }, - { - "EndIndex": 231842, - "Kind": 3 - }, - { - "EndIndex": 231857, - "Kind": 3 - }, - { - "EndIndex": 231888, - "Kind": 3 - }, - { - "EndIndex": 231954, - "Kind": 3 - }, - { - "EndIndex": 231968, - "Kind": 3 - }, - { - "EndIndex": 231974, - "Kind": 3 - }, - { - "EndIndex": 231992, - "Kind": 3 - }, - { - "EndIndex": 232034, - "Kind": 3 - }, - { - "EndIndex": 232360, - "Kind": 3 - }, - { - "EndIndex": 232382, - "Kind": 3 - }, - { - "EndIndex": 232388, - "Kind": 3 - }, - { - "EndIndex": 232403, - "Kind": 3 - }, - { - "EndIndex": 232433, - "Kind": 3 - }, - { - "EndIndex": 232471, - "Kind": 3 - }, - { - "EndIndex": 232485, - "Kind": 3 - }, - { - "EndIndex": 232491, - "Kind": 3 - }, - { - "EndIndex": 232493, - "Kind": 3 - }, - { - "EndIndex": 232517, - "Kind": 3 - }, - { - "EndIndex": 232649, - "Kind": 3 - }, - { - "EndIndex": 232668, - "Kind": 3 - }, - { - "EndIndex": 232670, - "Kind": 3 - }, - { - "EndIndex": 232690, - "Kind": 3 - }, - { - "EndIndex": 233001, - "Kind": 3 - }, - { - "EndIndex": 233022, - "Kind": 3 - }, - { - "EndIndex": 233061, - "Kind": 3 - }, - { - "EndIndex": 233100, - "Kind": 3 - }, - { - "EndIndex": 233114, - "Kind": 3 - }, - { - "EndIndex": 233120, - "Kind": 3 - }, - { - "EndIndex": 233162, - "Kind": 3 - }, - { - "EndIndex": 233477, - "Kind": 3 - }, - { - "EndIndex": 233491, - "Kind": 3 - }, - { - "EndIndex": 233497, - "Kind": 3 - }, - { - "EndIndex": 233515, - "Kind": 3 - }, - { - "EndIndex": 233548, - "Kind": 3 - }, - { - "EndIndex": 233699, - "Kind": 3 - }, - { - "EndIndex": 233720, - "Kind": 3 - }, - { - "EndIndex": 233726, - "Kind": 3 - }, - { - "EndIndex": 233751, - "Kind": 3 - }, - { - "EndIndex": 233784, - "Kind": 3 - }, - { - "EndIndex": 233806, - "Kind": 3 - }, - { - "EndIndex": 233812, - "Kind": 3 - }, - { - "EndIndex": 233837, - "Kind": 3 - }, - { - "EndIndex": 233870, - "Kind": 3 - }, - { - "EndIndex": 233884, - "Kind": 3 - }, - { - "EndIndex": 233890, - "Kind": 3 - }, - { - "EndIndex": 233917, - "Kind": 3 - }, - { - "EndIndex": 233967, - "Kind": 3 - }, - { - "EndIndex": 233997, - "Kind": 3 - }, - { - "EndIndex": 234003, - "Kind": 3 - }, - { - "EndIndex": 234021, - "Kind": 3 - }, - { - "EndIndex": 234063, - "Kind": 3 - }, - { - "EndIndex": 234389, - "Kind": 3 - }, - { - "EndIndex": 234411, - "Kind": 3 - }, - { - "EndIndex": 234417, - "Kind": 3 - }, - { - "EndIndex": 234419, - "Kind": 3 - } - ], - "FileSize": 234419, - "Id": -1981595346, - "Name": "builtins", - "IndexSpan": null -} \ No newline at end of file diff --git a/src/Caching/Test/Files/MemberLocations.json b/src/Caching/Test/Files/MemberLocations.json index 883fc6859..1269c8e2f 100644 --- a/src/Caching/Test/Files/MemberLocations.json +++ b/src/Caching/Test/Files/MemberLocations.json @@ -24,8 +24,8 @@ } ], "Attributes": 0, - "Classes": null, - "Functions": null, + "Classes": [], + "Functions": [], "Id": 799444, "Name": "sum", "IndexSpan": { @@ -36,7 +36,7 @@ ], "Variables": [ { - "Value": "bool", + "Value": "t:bool", "Id": -529376420, "Name": "__debug__", "IndexSpan": { @@ -45,7 +45,7 @@ } }, { - "Value": "str", + "Value": "t:str", "Id": -1636005055, "Name": "__doc__", "IndexSpan": { @@ -54,7 +54,7 @@ } }, { - "Value": "str", + "Value": "t:str", "Id": 875442003, "Name": "__file__", "IndexSpan": { @@ -63,7 +63,7 @@ } }, { - "Value": "str", + "Value": "t:str", "Id": 1097116834, "Name": "__name__", "IndexSpan": { @@ -72,7 +72,7 @@ } }, { - "Value": "str", + "Value": "t:str", "Id": 75395663, "Name": "__package__", "IndexSpan": { @@ -81,7 +81,7 @@ } }, { - "Value": "list", + "Value": "t:list", "Id": 1154586556, "Name": "__path__", "IndexSpan": { @@ -90,7 +90,7 @@ } }, { - "Value": "dict", + "Value": "t:dict", "Id": 817929997, "Name": "__dict__", "IndexSpan": { @@ -112,7 +112,7 @@ { "Documentation": null, "Bases": [ - "object" + "t:object" ], "Methods": [ { @@ -122,7 +122,7 @@ "Parameters": [ { "Name": "self", - "Type": "module:B", + "Type": "t:module:B", "DefaultValue": null, "Kind": 0 } @@ -131,8 +131,8 @@ } ], "Attributes": 0, - "Classes": null, - "Functions": null, + "Classes": [], + "Functions": [], "Id": 935009768, "Name": "methodB2", "IndexSpan": { @@ -160,24 +160,6 @@ "Id": 833, "Name": "x", "IndexSpan": null - }, - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } } ], "GenericParameters": null, @@ -185,7 +167,7 @@ { "Documentation": null, "Bases": [ - "object" + "t:object" ], "Methods": [ { @@ -195,7 +177,7 @@ "Parameters": [ { "Name": "self", - "Type": "module:C", + "Type": "t:module:C", "DefaultValue": null, "Kind": 0 } @@ -204,8 +186,8 @@ } ], "Attributes": 0, - "Classes": null, - "Functions": null, + "Classes": [], + "Functions": [], "Id": 965872103, "Name": "__init__", "IndexSpan": { @@ -220,7 +202,7 @@ "Parameters": [ { "Name": "self", - "Type": "module:C", + "Type": "t:module:C", "DefaultValue": null, "Kind": 0 } @@ -229,8 +211,8 @@ } ], "Attributes": 0, - "Classes": null, - "Functions": null, + "Classes": [], + "Functions": [], "Id": -1909501045, "Name": "methodC", "IndexSpan": { @@ -240,26 +222,7 @@ } ], "Properties": [], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], + "Fields": [], "GenericParameters": null, "InnerClasses": [], "Id": 780, diff --git a/src/Caching/Test/Files/NestedClasses.json b/src/Caching/Test/Files/NestedClasses.json index 4549d8e3e..1ef88efe2 100644 --- a/src/Caching/Test/Files/NestedClasses.json +++ b/src/Caching/Test/Files/NestedClasses.json @@ -4,7 +4,7 @@ "Functions": [], "Variables": [ { - "Value": "bool", + "Value": "t:bool", "Id": -529376420, "Name": "__debug__", "IndexSpan": { @@ -13,7 +13,7 @@ } }, { - "Value": "str", + "Value": "t:str", "Id": -1636005055, "Name": "__doc__", "IndexSpan": { @@ -22,7 +22,7 @@ } }, { - "Value": "str", + "Value": "t:str", "Id": 875442003, "Name": "__file__", "IndexSpan": { @@ -31,7 +31,7 @@ } }, { - "Value": "str", + "Value": "t:str", "Id": 1097116834, "Name": "__name__", "IndexSpan": { @@ -40,7 +40,7 @@ } }, { - "Value": "str", + "Value": "t:str", "Id": 75395663, "Name": "__package__", "IndexSpan": { @@ -49,7 +49,7 @@ } }, { - "Value": "list", + "Value": "t:list", "Id": 1154586556, "Name": "__path__", "IndexSpan": { @@ -58,7 +58,7 @@ } }, { - "Value": "dict", + "Value": "t:dict", "Id": 817929997, "Name": "__dict__", "IndexSpan": { @@ -89,7 +89,7 @@ { "Documentation": null, "Bases": [ - "object" + "t:object" ], "Methods": [ { @@ -99,7 +99,7 @@ "Parameters": [ { "Name": "self", - "Type": "module:A", + "Type": "t:module:A", "DefaultValue": null, "Kind": 0 } @@ -108,8 +108,8 @@ } ], "Attributes": 0, - "Classes": null, - "Functions": null, + "Classes": [], + "Functions": [], "Id": -1909501047, "Name": "methodA", "IndexSpan": { @@ -119,26 +119,7 @@ } ], "Properties": [], - "Fields": [ - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], + "Fields": [], "GenericParameters": null, "InnerClasses": [], "Id": 778, @@ -151,7 +132,7 @@ { "Documentation": null, "Bases": [ - "object" + "t:object" ], "Methods": [ { @@ -161,7 +142,7 @@ "Parameters": [ { "Name": "self", - "Type": "module:B", + "Type": "t:module:B", "DefaultValue": null, "Kind": 0 } @@ -170,8 +151,8 @@ } ], "Attributes": 0, - "Classes": null, - "Functions": null, + "Classes": [], + "Functions": [], "Id": 935009767, "Name": "methodB1", "IndexSpan": { @@ -186,7 +167,7 @@ "Parameters": [ { "Name": "self", - "Type": "module:B", + "Type": "t:module:B", "DefaultValue": null, "Kind": 0 } @@ -195,8 +176,8 @@ } ], "Attributes": 0, - "Classes": null, - "Functions": null, + "Classes": [], + "Functions": [], "Id": 935009768, "Name": "methodB2", "IndexSpan": { @@ -212,24 +193,6 @@ "Id": 833, "Name": "x", "IndexSpan": null - }, - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } } ], "GenericParameters": null, @@ -237,7 +200,7 @@ { "Documentation": null, "Bases": [ - "object" + "t:object" ], "Methods": [ { @@ -247,7 +210,7 @@ "Parameters": [ { "Name": "self", - "Type": "module:C", + "Type": "t:module:C", "DefaultValue": null, "Kind": 0 } @@ -256,8 +219,8 @@ } ], "Attributes": 0, - "Classes": null, - "Functions": null, + "Classes": [], + "Functions": [], "Id": 965872103, "Name": "__init__", "IndexSpan": { @@ -272,7 +235,7 @@ "Parameters": [ { "Name": "self", - "Type": "module:C", + "Type": "t:module:C", "DefaultValue": null, "Kind": 0 } @@ -281,8 +244,8 @@ } ], "Attributes": 0, - "Classes": null, - "Functions": null, + "Classes": [], + "Functions": [], "Id": -1909501045, "Name": "methodC", "IndexSpan": { @@ -298,24 +261,6 @@ "Id": 834, "Name": "y", "IndexSpan": null - }, - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } } ], "GenericParameters": null, diff --git a/src/Caching/Test/Files/Requests.json b/src/Caching/Test/Files/Requests.json deleted file mode 100644 index 9d3fa1f73..000000000 --- a/src/Caching/Test/Files/Requests.json +++ /dev/null @@ -1,991 +0,0 @@ -{ - "UniqueId": "requests(2.21.0)", - "Documentation": "Requests HTTP Library\r\n~~~~~~~~~~~~~~~~~~~~~\r\n\r\nRequests is an HTTP library, written in Python, for human beings. Basic GET\r\nusage:\r\n\r\n >>> import requests\r\n >>> r = requests.get('https://www.python.org')\r\n >>> r.status_code\r\n 200\r\n >>> 'Python is a programming language' in r.content\r\n True\r\n\r\n... or POST:\r\n\r\n >>> payload = dict(key1='value1', key2='value2')\r\n >>> r = requests.post('https://httpbin.org/post', data=payload)\r\n >>> print(r.text)\r\n {\r\n ...\r\n \"form\": {\r\n \"key2\": \"value2\",\r\n \"key1\": \"value1\"\r\n },\r\n ...\r\n }\r\n\r\nThe other HTTP methods are supported - see `requests.api`. Full documentation\r\nis at .\r\n\r\n:copyright: (c) 2017 by Kenneth Reitz.\r\n:license: Apache 2.0, see LICENSE for more details.\r\n", - "Functions": [ - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "urllib3_version", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "chardet_version", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 435179778, - "Name": "check_compatibility", - "IndexSpan": { - "Start": 973, - "Length": 19 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "cryptography_version", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -399540245, - "Name": "_check_cryptography", - "IndexSpan": { - "Start": 1808, - "Length": 19 - } - } - ], - "Variables": [ - { - "Value": "urllib3", - "Id": 1260465222, - "Name": "urllib3", - "IndexSpan": { - "Start": 878, - "Length": 7 - } - }, - { - "Value": "chardet", - "Id": -2125975290, - "Name": "chardet", - "IndexSpan": { - "Start": 893, - "Length": 7 - } - }, - { - "Value": "warnings", - "Id": 1876311406, - "Name": "warnings", - "IndexSpan": { - "Start": 908, - "Length": 8 - } - }, - { - "Value": "requests.exceptions:RequestsDependencyWarning", - "Id": -802098666, - "Name": "RequestsDependencyWarning", - "IndexSpan": { - "Start": 941, - "Length": 25 - } - }, - { - "Value": "urllib3.contrib.pyopenssl", - "Id": -1632802014, - "Name": "pyopenssl", - "IndexSpan": { - "Start": 2657, - "Length": 9 - } - }, - { - "Value": "urllib3.exceptions:DependencyWarning", - "Id": -891041158, - "Name": "DependencyWarning", - "IndexSpan": { - "Start": 2960, - "Length": 17 - } - }, - { - "Value": "i:str", - "Id": 916650529, - "Name": "__title__", - "IndexSpan": { - "Start": 3055, - "Length": 9 - } - }, - { - "Value": "i:str", - "Id": -1883656187, - "Name": "__description__", - "IndexSpan": { - "Start": 3066, - "Length": 15 - } - }, - { - "Value": "i:str", - "Id": -1620207176, - "Name": "__url__", - "IndexSpan": { - "Start": 3083, - "Length": 7 - } - }, - { - "Value": "i:str", - "Id": 1161199201, - "Name": "__version__", - "IndexSpan": { - "Start": 3092, - "Length": 11 - } - }, - { - "Value": "i:int", - "Id": -1840123721, - "Name": "__build__", - "IndexSpan": { - "Start": 3129, - "Length": 9 - } - }, - { - "Value": "i:str", - "Id": 1654469090, - "Name": "__author__", - "IndexSpan": { - "Start": 3140, - "Length": 10 - } - }, - { - "Value": "i:str", - "Id": -94198849, - "Name": "__author_email__", - "IndexSpan": { - "Start": 3152, - "Length": 16 - } - }, - { - "Value": "i:str", - "Id": -386551926, - "Name": "__license__", - "IndexSpan": { - "Start": 3170, - "Length": 11 - } - }, - { - "Value": "i:str", - "Id": 1739624272, - "Name": "__copyright__", - "IndexSpan": { - "Start": 3207, - "Length": 13 - } - }, - { - "Value": "i:str", - "Id": 782136591, - "Name": "__cake__", - "IndexSpan": { - "Start": 3222, - "Length": 8 - } - }, - { - "Value": "requests.utils", - "Id": 770082554, - "Name": "utils", - "IndexSpan": { - "Start": 3246, - "Length": 5 - } - }, - { - "Value": "requests.packages", - "Id": 2129088004, - "Name": "packages", - "IndexSpan": { - "Start": 3266, - "Length": 8 - } - }, - { - "Value": "requests.models:Request", - "Id": -104689032, - "Name": "Request", - "IndexSpan": { - "Start": 3295, - "Length": 7 - } - }, - { - "Value": "requests.models:Response", - "Id": 1102541176, - "Name": "Response", - "IndexSpan": { - "Start": 3304, - "Length": 8 - } - }, - { - "Value": "requests.models:PreparedRequest", - "Id": 1337118331, - "Name": "PreparedRequest", - "IndexSpan": { - "Start": 3314, - "Length": 15 - } - }, - { - "Value": "requests.api:request", - "Id": -1769342312, - "Name": "request", - "IndexSpan": { - "Start": 3347, - "Length": 7 - } - }, - { - "Value": "requests.api:get", - "Id": 787423, - "Name": "get", - "IndexSpan": { - "Start": 3356, - "Length": 3 - } - }, - { - "Value": "requests.api:head", - "Id": 24439415, - "Name": "head", - "IndexSpan": { - "Start": 3361, - "Length": 4 - } - }, - { - "Value": "requests.api:post", - "Id": 24687927, - "Name": "post", - "IndexSpan": { - "Start": 3367, - "Length": 4 - } - }, - { - "Value": "requests.api:patch", - "Id": 764909201, - "Name": "patch", - "IndexSpan": { - "Start": 3373, - "Length": 5 - } - }, - { - "Value": "requests.api:put", - "Id": 796568, - "Name": "put", - "IndexSpan": { - "Start": 3380, - "Length": 3 - } - }, - { - "Value": "requests.api:delete", - "Id": 1897257090, - "Name": "delete", - "IndexSpan": { - "Start": 3385, - "Length": 6 - } - }, - { - "Value": "requests.api:options", - "Id": 180457127, - "Name": "options", - "IndexSpan": { - "Start": 3393, - "Length": 7 - } - }, - { - "Value": "requests.sessions:session", - "Id": -880047457, - "Name": "session", - "IndexSpan": { - "Start": 3423, - "Length": 7 - } - }, - { - "Value": "requests.sessions:Session", - "Id": 784605823, - "Name": "Session", - "IndexSpan": { - "Start": 3432, - "Length": 7 - } - }, - { - "Value": "i:requests.structures:LookupDict", - "Id": 753305199, - "Name": "codes", - "IndexSpan": { - "Start": 3466, - "Length": 5 - } - }, - { - "Value": "requests.exceptions:RequestException", - "Id": 355509431, - "Name": "RequestException", - "IndexSpan": { - "Start": 3502, - "Length": 16 - } - }, - { - "Value": "requests.exceptions:Timeout", - "Id": 1780673866, - "Name": "Timeout", - "IndexSpan": { - "Start": 3520, - "Length": 7 - } - }, - { - "Value": "requests.exceptions:URLRequired", - "Id": 1361573271, - "Name": "URLRequired", - "IndexSpan": { - "Start": 3529, - "Length": 11 - } - }, - { - "Value": "requests.exceptions:TooManyRedirects", - "Id": 511002043, - "Name": "TooManyRedirects", - "IndexSpan": { - "Start": 3546, - "Length": 16 - } - }, - { - "Value": "requests.exceptions:HTTPError", - "Id": -1546903511, - "Name": "HTTPError", - "IndexSpan": { - "Start": 3564, - "Length": 9 - } - }, - { - "Value": "requests.exceptions:ConnectionError", - "Id": 853386419, - "Name": "ConnectionError", - "IndexSpan": { - "Start": 3575, - "Length": 15 - } - }, - { - "Value": "requests.exceptions:FileModeWarning", - "Id": 1675678790, - "Name": "FileModeWarning", - "IndexSpan": { - "Start": 3596, - "Length": 15 - } - }, - { - "Value": "requests.exceptions:ConnectTimeout", - "Id": -1047738098, - "Name": "ConnectTimeout", - "IndexSpan": { - "Start": 3613, - "Length": 14 - } - }, - { - "Value": "requests.exceptions:ReadTimeout", - "Id": -1711523244, - "Name": "ReadTimeout", - "IndexSpan": { - "Start": 3629, - "Length": 11 - } - }, - { - "Value": "logging", - "Id": 1772213096, - "Name": "logging", - "IndexSpan": { - "Start": 3719, - "Length": 7 - } - }, - { - "Value": "logging:NullHandler", - "Id": -1600735444, - "Name": "NullHandler", - "IndexSpan": { - "Start": 3747, - "Length": 11 - } - }, - { - "Value": "typing:Any", - "Id": 751189, - "Name": "Any", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Classes": [], - "NewLines": [ - { - "EndIndex": 24, - "Kind": 1 - }, - { - "EndIndex": 25, - "Kind": 1 - }, - { - "EndIndex": 32, - "Kind": 1 - }, - { - "EndIndex": 63, - "Kind": 1 - }, - { - "EndIndex": 93, - "Kind": 1 - }, - { - "EndIndex": 106, - "Kind": 1 - }, - { - "EndIndex": 107, - "Kind": 1 - }, - { - "EndIndex": 111, - "Kind": 1 - }, - { - "EndIndex": 133, - "Kind": 1 - }, - { - "EndIndex": 155, - "Kind": 1 - }, - { - "EndIndex": 156, - "Kind": 1 - }, - { - "EndIndex": 232, - "Kind": 1 - }, - { - "EndIndex": 239, - "Kind": 1 - }, - { - "EndIndex": 240, - "Kind": 1 - }, - { - "EndIndex": 263, - "Kind": 1 - }, - { - "EndIndex": 313, - "Kind": 1 - }, - { - "EndIndex": 334, - "Kind": 1 - }, - { - "EndIndex": 341, - "Kind": 1 - }, - { - "EndIndex": 396, - "Kind": 1 - }, - { - "EndIndex": 404, - "Kind": 1 - }, - { - "EndIndex": 405, - "Kind": 1 - }, - { - "EndIndex": 418, - "Kind": 1 - }, - { - "EndIndex": 419, - "Kind": 1 - }, - { - "EndIndex": 471, - "Kind": 1 - }, - { - "EndIndex": 538, - "Kind": 1 - }, - { - "EndIndex": 559, - "Kind": 1 - }, - { - "EndIndex": 564, - "Kind": 1 - }, - { - "EndIndex": 573, - "Kind": 1 - }, - { - "EndIndex": 588, - "Kind": 1 - }, - { - "EndIndex": 613, - "Kind": 1 - }, - { - "EndIndex": 637, - "Kind": 1 - }, - { - "EndIndex": 645, - "Kind": 1 - }, - { - "EndIndex": 654, - "Kind": 1 - }, - { - "EndIndex": 659, - "Kind": 1 - }, - { - "EndIndex": 660, - "Kind": 1 - }, - { - "EndIndex": 738, - "Kind": 1 - }, - { - "EndIndex": 774, - "Kind": 1 - }, - { - "EndIndex": 775, - "Kind": 1 - }, - { - "EndIndex": 814, - "Kind": 1 - }, - { - "EndIndex": 866, - "Kind": 1 - }, - { - "EndIndex": 870, - "Kind": 1 - }, - { - "EndIndex": 871, - "Kind": 1 - }, - { - "EndIndex": 886, - "Kind": 1 - }, - { - "EndIndex": 901, - "Kind": 1 - }, - { - "EndIndex": 917, - "Kind": 1 - }, - { - "EndIndex": 967, - "Kind": 1 - }, - { - "EndIndex": 968, - "Kind": 1 - }, - { - "EndIndex": 969, - "Kind": 1 - }, - { - "EndIndex": 1028, - "Kind": 1 - }, - { - "EndIndex": 1077, - "Kind": 1 - }, - { - "EndIndex": 1159, - "Kind": 1 - }, - { - "EndIndex": 1160, - "Kind": 1 - }, - { - "EndIndex": 1219, - "Kind": 1 - }, - { - "EndIndex": 1253, - "Kind": 1 - }, - { - "EndIndex": 1289, - "Kind": 1 - }, - { - "EndIndex": 1290, - "Kind": 1 - }, - { - "EndIndex": 1329, - "Kind": 1 - }, - { - "EndIndex": 1385, - "Kind": 1 - }, - { - "EndIndex": 1446, - "Kind": 1 - }, - { - "EndIndex": 1479, - "Kind": 1 - }, - { - "EndIndex": 1501, - "Kind": 1 - }, - { - "EndIndex": 1524, - "Kind": 1 - }, - { - "EndIndex": 1547, - "Kind": 1 - }, - { - "EndIndex": 1548, - "Kind": 1 - }, - { - "EndIndex": 1587, - "Kind": 1 - }, - { - "EndIndex": 1644, - "Kind": 1 - }, - { - "EndIndex": 1705, - "Kind": 1 - }, - { - "EndIndex": 1737, - "Kind": 1 - }, - { - "EndIndex": 1759, - "Kind": 1 - }, - { - "EndIndex": 1780, - "Kind": 1 - }, - { - "EndIndex": 1802, - "Kind": 1 - }, - { - "EndIndex": 1803, - "Kind": 1 - }, - { - "EndIndex": 1804, - "Kind": 1 - }, - { - "EndIndex": 1851, - "Kind": 1 - }, - { - "EndIndex": 1878, - "Kind": 1 - }, - { - "EndIndex": 1887, - "Kind": 1 - }, - { - "EndIndex": 1966, - "Kind": 1 - }, - { - "EndIndex": 1989, - "Kind": 1 - }, - { - "EndIndex": 2004, - "Kind": 1 - }, - { - "EndIndex": 2005, - "Kind": 1 - }, - { - "EndIndex": 2046, - "Kind": 1 - }, - { - "EndIndex": 2148, - "Kind": 1 - }, - { - "EndIndex": 2206, - "Kind": 1 - }, - { - "EndIndex": 2207, - "Kind": 1 - }, - { - "EndIndex": 2256, - "Kind": 1 - }, - { - "EndIndex": 2261, - "Kind": 1 - }, - { - "EndIndex": 2327, - "Kind": 1 - }, - { - "EndIndex": 2364, - "Kind": 1 - }, - { - "EndIndex": 2440, - "Kind": 1 - }, - { - "EndIndex": 2519, - "Kind": 1 - }, - { - "EndIndex": 2564, - "Kind": 1 - }, - { - "EndIndex": 2565, - "Kind": 1 - }, - { - "EndIndex": 2620, - "Kind": 1 - }, - { - "EndIndex": 2625, - "Kind": 1 - }, - { - "EndIndex": 2667, - "Kind": 1 - }, - { - "EndIndex": 2703, - "Kind": 1 - }, - { - "EndIndex": 2704, - "Kind": 1 - }, - { - "EndIndex": 2737, - "Kind": 1 - }, - { - "EndIndex": 2802, - "Kind": 1 - }, - { - "EndIndex": 2848, - "Kind": 1 - }, - { - "EndIndex": 2868, - "Kind": 1 - }, - { - "EndIndex": 2877, - "Kind": 1 - }, - { - "EndIndex": 2878, - "Kind": 1 - }, - { - "EndIndex": 2929, - "Kind": 1 - }, - { - "EndIndex": 2978, - "Kind": 1 - }, - { - "EndIndex": 3029, - "Kind": 1 - }, - { - "EndIndex": 3030, - "Kind": 1 - }, - { - "EndIndex": 3104, - "Kind": 1 - }, - { - "EndIndex": 3182, - "Kind": 1 - }, - { - "EndIndex": 3231, - "Kind": 1 - }, - { - "EndIndex": 3232, - "Kind": 1 - }, - { - "EndIndex": 3252, - "Kind": 1 - }, - { - "EndIndex": 3275, - "Kind": 1 - }, - { - "EndIndex": 3330, - "Kind": 1 - }, - { - "EndIndex": 3401, - "Kind": 1 - }, - { - "EndIndex": 3440, - "Kind": 1 - }, - { - "EndIndex": 3472, - "Kind": 1 - }, - { - "EndIndex": 3498, - "Kind": 1 - }, - { - "EndIndex": 3542, - "Kind": 1 - }, - { - "EndIndex": 3592, - "Kind": 1 - }, - { - "EndIndex": 3641, - "Kind": 1 - }, - { - "EndIndex": 3643, - "Kind": 1 - }, - { - "EndIndex": 3644, - "Kind": 1 - }, - { - "EndIndex": 3712, - "Kind": 1 - }, - { - "EndIndex": 3727, - "Kind": 1 - }, - { - "EndIndex": 3759, - "Kind": 1 - }, - { - "EndIndex": 3760, - "Kind": 1 - }, - { - "EndIndex": 3814, - "Kind": 1 - }, - { - "EndIndex": 3815, - "Kind": 1 - }, - { - "EndIndex": 3858, - "Kind": 1 - }, - { - "EndIndex": 3921, - "Kind": 1 - } - ], - "FileSize": 3921, - "Id": -203071489, - "Name": "requests", - "IndexSpan": null -} \ No newline at end of file diff --git a/src/Caching/Test/Files/SmokeTest.json b/src/Caching/Test/Files/SmokeTest.json index 66c6cd305..be1c77d98 100644 --- a/src/Caching/Test/Files/SmokeTest.json +++ b/src/Caching/Test/Files/SmokeTest.json @@ -11,8 +11,8 @@ } ], "Attributes": 0, - "Classes": null, - "Functions": null, + "Classes": [], + "Functions": [], "Id": 24395611, "Name": "func", "IndexSpan": { @@ -23,7 +23,7 @@ ], "Variables": [ { - "Value": "bool", + "Value": "t:bool", "Id": -529376420, "Name": "__debug__", "IndexSpan": { @@ -32,7 +32,7 @@ } }, { - "Value": "str", + "Value": "t:str", "Id": -1636005055, "Name": "__doc__", "IndexSpan": { @@ -41,7 +41,7 @@ } }, { - "Value": "str", + "Value": "t:str", "Id": 875442003, "Name": "__file__", "IndexSpan": { @@ -50,7 +50,7 @@ } }, { - "Value": "str", + "Value": "t:str", "Id": 1097116834, "Name": "__name__", "IndexSpan": { @@ -59,7 +59,7 @@ } }, { - "Value": "str", + "Value": "t:str", "Id": 75395663, "Name": "__package__", "IndexSpan": { @@ -68,7 +68,7 @@ } }, { - "Value": "list", + "Value": "t:list", "Id": 1154586556, "Name": "__path__", "IndexSpan": { @@ -77,7 +77,7 @@ } }, { - "Value": "dict", + "Value": "t:dict", "Id": 817929997, "Name": "__dict__", "IndexSpan": { @@ -108,7 +108,7 @@ { "Documentation": null, "Bases": [ - "object" + "t:object" ], "Methods": [ { @@ -118,7 +118,7 @@ "Parameters": [ { "Name": "self", - "Type": "module:C", + "Type": "t:module:C", "DefaultValue": null, "Kind": 0 } @@ -127,8 +127,8 @@ } ], "Attributes": 0, - "Classes": null, - "Functions": null, + "Classes": [], + "Functions": [], "Id": 965872103, "Name": "__init__", "IndexSpan": { @@ -143,7 +143,7 @@ "Parameters": [ { "Name": "self", - "Type": "module:C", + "Type": "t:module:C", "DefaultValue": null, "Kind": 0 } @@ -152,8 +152,8 @@ } ], "Attributes": 0, - "Classes": null, - "Functions": null, + "Classes": [], + "Functions": [], "Id": -2139806792, "Name": "method", "IndexSpan": { @@ -187,24 +187,6 @@ "Id": 834, "Name": "y", "IndexSpan": null - }, - { - "Value": "dict", - "Id": 817929997, - "Name": "__dict__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "object", - "Id": 1225024228, - "Name": "__weakref__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } } ], "GenericParameters": null, diff --git a/src/Caching/Test/Files/Sys.json b/src/Caching/Test/Files/Sys.json deleted file mode 100644 index 81e6f9371..000000000 --- a/src/Caching/Test/Files/Sys.json +++ /dev/null @@ -1,12601 +0,0 @@ -{ - "UniqueId": "sys(3.7)", - "Documentation": "This module provides access to some objects used or maintained by the\ninterpreter and to functions that interact strongly with the interpreter.\n\nDynamic objects:\n\nargv -- command line arguments; argv[0] is the script pathname if known\npath -- module search path; path[0] is the script directory, else ''\nmodules -- dictionary of loaded modules\n\ndisplayhook -- called to show results in an interactive session\nexcepthook -- called to handle any uncaught exception other than SystemExit\n To customize printing in an interactive session or to install a custom\n top-level exception handler, assign other functions to replace these.\n\nstdin -- standard input file object; used by input()\nstdout -- standard output file object; used by print()\nstderr -- standard error object; used for error messages\n By assigning other file objects (or objects that behave like files)\n to these, it is possible to redirect all of the interpreter's I/O.\n\nlast_type -- type of last uncaught exception\nlast_value -- value of last uncaught exception\nlast_traceback -- traceback of last uncaught exception\n These three are only available in an interactive session after a\n traceback has been printed.\n\nStatic objects:\n\nbuiltin_module_names -- tuple of module names built into this interpreter\ncopyright -- copyright notice pertaining to this interpreter\nexec_prefix -- prefix used to find the machine-specific Python library\nexecutable -- absolute path of the executable binary of the Python interpreter\nfloat_info -- a struct sequence with information about the float implementation.\nfloat_repr_style -- string indicating the style of repr() output for floats\nhash_info -- a struct sequence with information about the hash algorithm.\nhexversion -- version information encoded as a single integer\nimplementation -- Python implementation information.\nint_info -- a struct sequence with information about the int implementation.\nmaxsize -- the largest supported length of containers.\nmaxunicode -- the value of the largest Unicode code point\nplatform -- platform identifier\nprefix -- prefix used to find the Python library\nthread_info -- a struct sequence with information about the thread implementation.\nversion -- the version of this interpreter as a string\nversion_info -- version information as a named tuple\ndllhandle -- [Windows only] integer handle of the Python DLL\nwinver -- [Windows only] version number of the Python DLL\n_enablelegacywindowsfsencoding -- [Windows only] \n__stdin__ -- the original stdin; don't touch!\n__stdout__ -- the original stdout; don't touch!\n__stderr__ -- the original stderr; don't touch!\n__displayhook__ -- the original displayhook; don't touch!\n__excepthook__ -- the original excepthook; don't touch!\n\nFunctions:\n\ndisplayhook() -- print an object to the screen, and save it in builtins._\nexcepthook() -- print an exception and its traceback to sys.stderr\nexc_info() -- return thread-safe information about the current exception\nexit() -- exit the interpreter by raising SystemExit\ngetdlopenflags() -- returns flags to be used for dlopen() calls\ngetprofile() -- get the global profiling function\ngetrefcount() -- return the reference count for an object (plus one :-)\ngetrecursionlimit() -- return the max recursion depth for the interpreter\ngetsizeof() -- return the size of an object in bytes\ngettrace() -- get the global debug tracing function\nsetcheckinterval() -- control how often the interpreter checks for events\nsetdlopenflags() -- set the flags to be used for dlopen() calls\nsetprofile() -- set the global profiling function\nsetrecursionlimit() -- set the max recursion depth for the interpreter\nsettrace() -- set the global debug tracing function\n", - "Functions": [ - { - "Documentation": "breakpointhook(*args, **kws)\n\nThis hook function is called by built-in breakpoint().\n", - "Overloads": [ - { - "Parameters": [], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1623088213, - "Name": "__breakpointhook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "displayhook(object) -> None\n\nPrint an object to sys.stdout and also save it in builtins._\n", - "Overloads": [ - { - "Parameters": [], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 629764782, - "Name": "__displayhook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "excepthook(exctype, value, traceback) -> None\n\nHandle an exception by displaying it with a traceback on sys.stderr.\n", - "Overloads": [ - { - "Parameters": [], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1425218131, - "Name": "__excepthook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1727507378, - "Name": "__interactivehook__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "_clear_type_cache() -> None\nClear the internal type lookup cache.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": "i:__NoneType__" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1527505257, - "Name": "_clear_type_cache", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "_current_frames() -> dictionary\n\nReturn a dictionary mapping each current thread T's thread id to T's\ncurrent stack frame.\n\nThis function should be used for specialized purposes only.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": "i:dict" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 813545300, - "Name": "_current_frames", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "_debugmallocstats()\n\nPrint summary info to stderr about the state of\npymalloc's structures.\n\nIn Py_DEBUG mode, also perform some expensive internal consistency\nchecks.\n", - "Overloads": [ - { - "Parameters": [], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1370295892, - "Name": "_debugmallocstats", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "_enablelegacywindowsfsencoding()\n\nChanges the default filesystem encoding to mbcs:replace for consistency\nwith earlier versions of Python. See PEP 529 for more information.\n\nThis is equivalent to defining the PYTHONLEGACYWINDOWSFSENCODING \nenvironment variable before launching Python.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1047770159, - "Name": "_enablelegacywindowsfsencoding", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "_getframe([depth]) -> frameobject\n\nReturn a frame object from the call stack. If optional integer depth is\ngiven, return the frame object that many calls below the top of the stack.\nIf that is deeper than the call stack, ValueError is raised. The default\nfor depth is zero, returning the frame at the top of the call stack.\n\nThis function should be used for internal and specialized\npurposes only.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": "i:types:FrameType" - }, - { - "Parameters": [ - { - "Name": "depth", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:types:FrameType" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1848744703, - "Name": "_getframe", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "breakpointhook(*args, **kws)\n\nThis hook function is called by built-in breakpoint().\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kws", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1414470549, - "Name": "breakpointhook", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "call_tracing(func, args) -> object\n\nCall func(*args), while tracing is enabled. The tracing state is\nsaved, and restored afterwards. This is intended to be called from\na debugger from a checkpoint, to recursively debug some other code.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "fn", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": "typing:Any", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:typing:_T" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1158985352, - "Name": "call_tracing", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "callstats() -> tuple of integers\n\nReturn a tuple of function call statistics, if CALL_PROFILE was defined\nwhen Python was built. Otherwise, return None.\n\nWhen enabled, this function returns detailed, implementation-specific\ndetails about the number of function calls executed. The return value is\na 11-tuple where the entries in the tuple are counts of:\n0. all function calls\n1. calls to PyFunction_Type objects\n2. PyFunction calls that do not create an argument tuple\n3. PyFunction calls that do not create an argument tuple\n and bypass PyEval_EvalCodeEx()\n4. PyMethod calls\n5. PyMethod calls on bound methods\n6. PyType calls\n7. PyCFunction calls\n8. generator calls\n9. All other calls\n10. Number of stack pops performed by call_function()", - "Overloads": [ - { - "Parameters": [], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1252442422, - "Name": "callstats", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "displayhook(object) -> None\n\nPrint an object to sys.stdout and also save it in builtins._\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "value", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:__NoneType__" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 388872302, - "Name": "displayhook", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "exc_info() -> (type, value, traceback)\n\nReturn information about the most recent exception caught by an except\nclause in the current stack frame or in an older stack frame.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -935045484, - "Name": "exc_info", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "excepthook(exctype, value, traceback) -> None\n\nHandle an exception by displaying it with a traceback on sys.stderr.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "type_", - "Type": "typing:Type[BaseException]", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": "BaseException", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "traceback", - "Type": "types:TracebackType", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:__NoneType__" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 305517843, - "Name": "excepthook", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "exit([status])\n\nExit the interpreter by raising SystemExit(status).\nIf the status is omitted or None, it defaults to zero (i.e., success).\nIf the status is an integer, it will be used as the system exit status.\nIf it is another kind of object, it will be printed and the system\nexit status will be one (i.e., failure).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "arg", - "Type": "object", - "DefaultValue": "i:ellipsis", - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 24368565, - "Name": "exit", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "get_asyncgen_hooks()\n\nReturn a namedtuple of installed asynchronous generators hooks (firstiter, finalizer).", - "Overloads": [ - { - "Parameters": [], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -932626587, - "Name": "get_asyncgen_hooks", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Check status of origin tracking for coroutine objects in this thread.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1605124845, - "Name": "get_coroutine_origin_tracking_depth", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "get_coroutine_wrapper()\n\nReturn the wrapper for coroutine objects set by sys.set_coroutine_wrapper.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1829443124, - "Name": "get_coroutine_wrapper", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "getallocatedblocks() -> integer\n\nReturn the number of memory blocks currently allocated, regardless of their\nsize.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1953654962, - "Name": "getallocatedblocks", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "getcheckinterval() -> current check interval; see setcheckinterval().", - "Overloads": [ - { - "Parameters": [], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 2065023054, - "Name": "getcheckinterval", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "getdefaultencoding() -> string\n\nReturn the current default string encoding used by the Unicode \nimplementation.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1935348949, - "Name": "getdefaultencoding", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "getfilesystemencodeerrors() -> string\n\nReturn the error mode used to convert Unicode filenames in\noperating system filenames.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 346962379, - "Name": "getfilesystemencodeerrors", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "getfilesystemencoding() -> string\n\nReturn the encoding used to convert Unicode filenames in\noperating system filenames.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -946006243, - "Name": "getfilesystemencoding", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "getprofile()\n\nReturn the profiling function set with sys.setprofile.\nSee the profiler chapter in the library manual.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 682573034, - "Name": "getprofile", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "getrecursionlimit()\n\nReturn the current value of the recursion limit, the maximum depth\nof the Python interpreter stack. This limit prevents infinite\nrecursion from causing an overflow of the C stack and crashing Python.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 949225272, - "Name": "getrecursionlimit", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "getrefcount(object) -> integer\n\nReturn the reference count of object. The count returned is generally\none higher than you might expect, because it includes the (temporary)\nreference as an argument to getrefcount().", - "Overloads": [ - { - "Parameters": [ - { - "Name": "arg", - "Type": "typing:Any", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -37310149, - "Name": "getrefcount", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "getsizeof(object, default) -> int\n\nReturn the size of object in bytes.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "obj", - "Type": "object", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - }, - { - "Parameters": [ - { - "Name": "obj", - "Type": "object", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "default", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1485394487, - "Name": "getsizeof", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "getswitchinterval() -> current thread switch interval; see setswitchinterval().", - "Overloads": [ - { - "Parameters": [], - "ReturnType": "i:float" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1633191528, - "Name": "getswitchinterval", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "gettrace()\n\nReturn the global debug tracing function set with sys.settrace.\nSee the debugger chapter in the library manual.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -920747834, - "Name": "gettrace", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "getwindowsversion()\n\nReturn information about the running version of Windows as a named tuple.\nThe members are named: major, minor, build, platform, service_pack,\nservice_pack_major, service_pack_minor, suite_mask, and product_type. For\nbackward compatibility, only the first 5 items are available by indexing.\nAll elements are numbers, except service_pack and platform_type which are\nstrings, and platform_version which is a 3-tuple. Platform is always 2.\nProduct_type may be 1 for a workstation, 2 for a domain controller, 3 for a\nserver. Platform_version is a 3-tuple containing a version number that is\nintended for identifying the OS rather than feature detection.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": "i:sys:_WinVersion" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1280212332, - "Name": "getwindowsversion", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "intern(string) -> string\n\n``Intern'' the given string. This enters the string in the (global)\ntable of interned strings whose purpose is to speed up dictionary lookups.\nReturn the string itself or the previously interned string object with the\nsame value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "string", - "Type": "str", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 2048952809, - "Name": "intern", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "is_finalizing()\nReturn True if Python is exiting.", - "Overloads": [ - { - "Parameters": [], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1710543065, - "Name": "is_finalizing", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "set_asyncgen_hooks(*, firstiter=None, finalizer=None)\n\nSet a finalizer for async generators objects.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "firstiter", - "Type": null, - "DefaultValue": null, - "Kind": 3 - }, - { - "Name": "finalizer", - "Type": null, - "DefaultValue": null, - "Kind": 3 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -12592935, - "Name": "set_asyncgen_hooks", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Enable or disable origin tracking for coroutine objects in this thread.\n\nCoroutine objects will track 'depth' frames of traceback information about\nwhere they came from, available in their cr_origin attribute. Set depth of 0\nto disable.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "depth", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 836059129, - "Name": "set_coroutine_origin_tracking_depth", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "set_coroutine_wrapper(wrapper)\n\nSet a wrapper for coroutine objects.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "wrapper", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 706767832, - "Name": "set_coroutine_wrapper", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "setcheckinterval(n)\n\nTell the Python interpreter to check for asynchronous events every\nn instructions. This also affects how often thread switches occur.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "interval", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:__NoneType__" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 233580226, - "Name": "setcheckinterval", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "setprofile(function)\n\nSet the profiling function. It will be called on each function call\nand return. See the profiler chapter in the library manual.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "profilefunc", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:__NoneType__" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1675589026, - "Name": "setprofile", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "setrecursionlimit(n)\n\nSet the maximum depth of the Python interpreter stack to n. This\nlimit prevents infinite recursion from causing an overflow of the C\nstack and crashing Python. The highest possible limit is platform-\ndependent.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "limit", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:__NoneType__" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 9072452, - "Name": "setrecursionlimit", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "setswitchinterval(n)\n\nSet the ideal thread switching delay inside the Python interpreter\nThe actual frequency of switching threads can be lower if the\ninterpreter executes long sequences of uninterruptible code\n(this is implementation-specific and workload-dependent).\n\nThe parameter must represent the desired switching delay in seconds\nA typical value is 0.005 (5 milliseconds).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "interval", - "Type": "float", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:__NoneType__" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1721622948, - "Name": "setswitchinterval", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "settrace(function)\n\nSet the global debug tracing function. It will be called on each\nfunction call. See the debugger chapter in the library manual.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "tracefunc", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:__NoneType__" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1481860294, - "Name": "settrace", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 503242166, - "Name": "getdlopenflags", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "n", - "Type": "int", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:__NoneType__" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1268494038, - "Name": "setdlopenflags", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "on_flag", - "Type": "bool", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:__NoneType__" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1891924589, - "Name": "settscdump", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1618095583, - "Name": "gettotalrefcount", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Variables": [ - { - "Value": "_io", - "Id": 668243680, - "Name": "_mod__io", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "builtins", - "Id": -1070584715, - "Name": "_mod_builtins", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "types", - "Id": -2043043116, - "Name": "_mod_types", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:str", - "Id": -1636005055, - "Name": "__doc__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:str", - "Id": 1097116834, - "Name": "__name__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:str", - "Id": 75395663, - "Name": "__package__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:_io:TextIOWrapper", - "Id": 1612032761, - "Name": "__stderr__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:_io:TextIOWrapper", - "Id": 329210449, - "Name": "__stdin__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:_io:TextIOWrapper", - "Id": 1621359266, - "Name": "__stdout__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:str", - "Id": 677051350, - "Name": "_framework", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:tuple", - "Id": 24173482, - "Name": "_git", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:NoneType", - "Id": 749413383, - "Name": "_home", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:dict", - "Id": 1595009614, - "Name": "_xoptions", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:int", - "Id": 1834311484, - "Name": "api_version", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:list", - "Id": 24243575, - "Name": "argv", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:str", - "Id": 1664944041, - "Name": "base_exec_prefix", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:str", - "Id": 1039099721, - "Name": "base_prefix", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:list", - "Id": 1963179240, - "Name": "builtin_module_names", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:str", - "Id": 2033693967, - "Name": "byteorder", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:str", - "Id": 1298046352, - "Name": "copyright", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:int", - "Id": -1200168491, - "Name": "dllhandle", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:bool", - "Id": 1675585612, - "Name": "dont_write_bytecode", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:str", - "Id": 62274953, - "Name": "exec_prefix", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:str", - "Id": -2135911519, - "Name": "executable", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:str", - "Id": 92603457, - "Name": "float_repr_style", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:int", - "Id": -471599948, - "Name": "hexversion", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:_implementation", - "Id": 1997289353, - "Name": "implementation", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:int", - "Id": -2020000914, - "Name": "maxsize", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:int", - "Id": 842058832, - "Name": "maxunicode", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:list", - "Id": -1294259224, - "Name": "meta_path", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:dict", - "Id": -1637601392, - "Name": "modules", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:list", - "Id": 24674492, - "Name": "path", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:list", - "Id": -1506404755, - "Name": "path_hooks", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:dict", - "Id": 376899064, - "Name": "path_importer_cache", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:str", - "Id": -1042062966, - "Name": "platform", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:str", - "Id": -2042362519, - "Name": "prefix", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:_io:TextIOWrapper", - "Id": -1954658503, - "Name": "stderr", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:_io:TextIOWrapper", - "Id": 768230609, - "Name": "stdin", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:_io:TextIOWrapper", - "Id": -1954648798, - "Name": "stdout", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:str", - "Id": 1781540065, - "Name": "version", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:list", - "Id": -707130143, - "Name": "warnoptions", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:str", - "Id": -1849986786, - "Name": "winver", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:sys:__float_info", - "Id": 602612744, - "Name": "float_info", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:sys:__hash_info", - "Id": 84475656, - "Name": "hash_info", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:sys:__int_info", - "Id": 1942821909, - "Name": "int_info", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:sys:__thread_info", - "Id": 604643660, - "Name": "thread_info", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:sys:__version_info", - "Id": 1738857804, - "Name": "version_info", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "typing:List", - "Id": 23609685, - "Name": "List", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "typing:Sequence", - "Id": -1502554888, - "Name": "Sequence", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "typing:Any", - "Id": 751189, - "Name": "Any", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "typing:Dict", - "Id": 23370861, - "Name": "Dict", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "typing:Tuple", - "Id": 739642865, - "Name": "Tuple", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "typing:Optional", - "Id": 1363847319, - "Name": "Optional", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "typing:Union", - "Id": 740351224, - "Name": "Union", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "typing:TypeVar", - "Id": -2053481098, - "Name": "TypeVar", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "typing:Type", - "Id": 23863281, - "Name": "Type", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "types:FrameType", - "Id": -1970702352, - "Name": "FrameType", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "_importlib_modulespec:ModuleType", - "Id": -1551859907, - "Name": "ModuleType", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "types:TracebackType", - "Id": -612342225, - "Name": "TracebackType", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "importlib.abc:MetaPathFinder", - "Id": -1792761721, - "Name": "MetaPathFinder", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "typing:_T", - "Id": 25132, - "Name": "_T", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:types:TracebackType", - "Id": 2060329242, - "Name": "last_traceback", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Value": "i:tuple", - "Id": -1174870545, - "Name": "subversion", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - } - ], - "Classes": [ - { - "Documentation": "sys.flags\n\nFlags provided through command line arguments or environment vars.", - "Bases": [ - "tuple", - "object" - ], - "Methods": [ - { - "Documentation": "Return self+value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1639102358, - "Name": "__add__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return key in self.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1841774666, - "Name": "__contains__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement delattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:NoneType" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 2095540485, - "Name": "__delattr__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Default dir() implementation.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:list" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1636169386, - "Name": "__dir__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self==value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748372547, - "Name": "__eq__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Default object formatter.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "format_spec", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:str" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 695475534, - "Name": "__format__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self[key].", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -293179214, - "Name": "__getitem__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -488627138, - "Name": "__getnewargs__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return hash(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "sys.flags\n\nFlags provided through command line arguments or environment vars.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:NoneType" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return len(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1628904226, - "Name": "__len__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__float_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__float_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self[key].", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__float_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -293179214, - "Name": "__getitem__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "sys:__float_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -488627138, - "Name": "__getnewargs__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__float_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return hash(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__float_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "sys.float_info\n\nA structseq holding information about the float type. It contains low level\ninformation about the precision and internal representation. Please study\nyour system's :file:`float.h` for more information.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__float_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "sys:__float_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:NoneType" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__float_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__float_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return len(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__float_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1628904226, - "Name": "__len__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__hash_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__hash_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self[key].", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__hash_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -293179214, - "Name": "__getitem__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "sys:__hash_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -488627138, - "Name": "__getnewargs__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__hash_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return hash(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__hash_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "hash_info\n\nA struct sequence providing parameters used for computing\nhashes. The attributes are read only.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__hash_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "sys:__hash_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:NoneType" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__hash_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__hash_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return len(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__hash_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1628904226, - "Name": "__len__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__int_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__int_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self[key].", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__int_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -293179214, - "Name": "__getitem__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "sys:__int_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -488627138, - "Name": "__getnewargs__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__int_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return hash(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__int_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "sys.int_info\n\nA struct sequence that holds information about Python's\ninternal representation of integers. The attributes are read only.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__int_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "sys:__int_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:NoneType" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__int_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__int_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return len(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__int_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1628904226, - "Name": "__len__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__thread_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__thread_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self[key].", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__thread_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -293179214, - "Name": "__getitem__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "sys:__thread_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -488627138, - "Name": "__getnewargs__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__thread_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return hash(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__thread_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "sys.thread_info\n\nA struct sequence holding information about the thread implementation.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__thread_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "sys:__thread_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:NoneType" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Implement iter(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__thread_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 971292143, - "Name": "__iter__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__thread_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return len(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__thread_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1628904226, - "Name": "__len__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__version_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748420597, - "Name": "__ge__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return getattr(self, name).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__version_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "name", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1329277859, - "Name": "__getattribute__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self[key].", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__version_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "key", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -293179214, - "Name": "__getitem__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": null, - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "sys:__version_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "self", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:tuple" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -488627138, - "Name": "__getnewargs__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self>value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__version_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748435012, - "Name": "__gt__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return hash(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__version_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 925523557, - "Name": "__hash__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "sys.version_info\n\nVersion information as a named tuple.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__version_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "args", - "Type": null, - "DefaultValue": null, - "Kind": 1 - }, - { - "Name": "kwargs", - "Type": null, - "DefaultValue": null, - "Kind": 2 - } - ], - "ReturnType": null - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 965872103, - "Name": "__init__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n", - "Overloads": [ - { - "Parameters": [ - { - "Name": "cls", - "Type": "sys:__version_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:NoneType" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1040523408, - "Name": "__init_subclass__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self<=value.", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__version_info", - "DefaultValue": null, - "Kind": 0 - }, - { - "Name": "value", - "Type": null, - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:bool" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": 1748569552, - "Name": "__le__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return len(self).", - "Overloads": [ - { - "Parameters": [ - { - "Name": "self", - "Type": "sys:__version_info", - "DefaultValue": null, - "Kind": 0 - } - ], - "ReturnType": "i:int" - } - ], - "Attributes": 0, - "Classes": null, - "Functions": null, - "Id": -1628904226, - "Name": "__len__", - "IndexSpan": { - "Start": 0, - "Length": 0 - } - }, - { - "Documentation": "Return self GetBaselineFileName(TestContext.TestName); [TestMethod, Priority(0)] + [Ignore("Builtins module have custom member handling. We do not persist it yet.")] public async Task Builtins() { var analysis = await GetAnalysisAsync(string.Empty); var builtins = analysis.Document.Interpreter.ModuleResolution.BuiltinsModule; @@ -53,18 +54,22 @@ public async Task Builtins() { [TestMethod, Priority(0)] - public async Task Sys() { - var analysis = await GetAnalysisAsync("import sys"); - var sys = analysis.Document.Interpreter.ModuleResolution.GetImportedModule("sys"); - var model = ModuleModel.FromAnalysis(sys.Analysis, Services); + public Task Sys() => TestModule("sys"); - var json = ToJson(model); - Baseline.CompareToFile(BaselineFileName, json); + [TestMethod, Priority(0)] + public Task Io() => TestModule("io"); - using (var dbModule = new PythonDbModule(model, sys.FilePath, Services)) { - dbModule.Should().HaveSameMembersAs(sys); - } - } + [TestMethod, Priority(0)] + public Task Re() => TestModule("re"); + + [TestMethod, Priority(0)] + public Task Os() => TestModule("os"); + + [TestMethod, Priority(0)] + public Task Logging() => TestModule("logging"); + + [TestMethod, Priority(0)] + public Task Types() => TestModule("types"); [TestMethod, Priority(0)] public async Task Requests() { @@ -88,11 +93,23 @@ import requests // Verify this looks like a version. new Version(u.Substring(open + 1, u.IndexOf(')') - open - 1)); - var json = ToJson(model); - Baseline.CompareToFile(BaselineFileName, json); + CompareBaselineAndRestore(model, rq); + } + + private async Task TestModule(string name) { + var analysis = await GetAnalysisAsync($"import {name}"); + var m = analysis.Document.Interpreter.ModuleResolution.GetImportedModule(name); + var model = ModuleModel.FromAnalysis(m.Analysis, Services); + + CompareBaselineAndRestore(model, m); + } + + private void CompareBaselineAndRestore(ModuleModel model, IPythonModule m) { + //var json = ToJson(model); + //Baseline.CompareToFile(BaselineFileName, json); - using (var dbModule = new PythonDbModule(model, rq.FilePath, Services)) { - dbModule.Should().HaveSameMembersAs(rq); + using (var dbModule = new PythonDbModule(model, m.FilePath, Services)) { + dbModule.Should().HaveSameMembersAs(m); } } } diff --git a/src/Caching/Test/ReferencesTests.cs b/src/Caching/Test/ReferencesTests.cs index 435b8df76..ca75fb8fe 100644 --- a/src/Caching/Test/ReferencesTests.cs +++ b/src/Caching/Test/ReferencesTests.cs @@ -104,8 +104,8 @@ import logging var model = ModuleModel.FromAnalysis(logging.Analysis, Services); var dbModule = new PythonDbModule(model, logging.FilePath, Services); - analysis.Document.Interpreter.ModuleResolution.SpecializeModule("logging", x => dbModule); - + analysis.Document.Interpreter.ModuleResolution.SpecializeModule("logging", x => dbModule, replaceExisting: true); + var moduleName = $"{analysis.Document.Name}_db.py"; var modulePath = TestData.GetTestSpecificPath(moduleName); analysis = await GetAnalysisAsync(code, Services, moduleName, modulePath); diff --git a/src/LanguageServer/Impl/Completion/ExpressionCompletion.cs b/src/LanguageServer/Impl/Completion/ExpressionCompletion.cs index a199acae7..5e9ff8d33 100644 --- a/src/LanguageServer/Impl/Completion/ExpressionCompletion.cs +++ b/src/LanguageServer/Impl/Completion/ExpressionCompletion.cs @@ -13,15 +13,13 @@ // See the Apache Version 2.0 License for specific language governing // permissions and limitations under the License. -using System.Collections.Generic; -using System.Linq; using Microsoft.Python.Analysis; -using Microsoft.Python.Analysis.Analyzer; using Microsoft.Python.Analysis.Types; using Microsoft.Python.Analysis.Values; -using Microsoft.Python.Core; using Microsoft.Python.LanguageServer.Protocol; using Microsoft.Python.Parsing.Ast; +using System.Collections.Generic; +using System.Linq; namespace Microsoft.Python.LanguageServer.Completion { internal static class ExpressionCompletion { diff --git a/src/LanguageServer/Impl/Implementation/Server.Telemetry.cs b/src/LanguageServer/Impl/Implementation/Server.Telemetry.cs index 97a954490..4dcfdd079 100644 --- a/src/LanguageServer/Impl/Implementation/Server.Telemetry.cs +++ b/src/LanguageServer/Impl/Implementation/Server.Telemetry.cs @@ -48,6 +48,7 @@ private void OnAnalysisComplete(object sender, AnalysisCompleteEventArgs e) { te.Measurements["workingMB"] = workingMB; te.Measurements["elapsedMs"] = e.MillisecondsElapsed; te.Measurements["moduleCount"] = e.ModuleCount; + te.Measurements["rdtCount"] = _rdt.DocumentCount; telemetry.SendTelemetryAsync(te).DoNotWait(); } diff --git a/src/LanguageServer/Impl/Implementation/Server.cs b/src/LanguageServer/Impl/Implementation/Server.cs index 5b54c9714..2db04f569 100644 --- a/src/LanguageServer/Impl/Implementation/Server.cs +++ b/src/LanguageServer/Impl/Implementation/Server.cs @@ -15,7 +15,6 @@ using System; using System.Diagnostics; -using System.IO; using System.Linq; using System.Reflection; using System.Threading; @@ -125,9 +124,14 @@ public async Task InitializeAsync(InitializeParams @params, Ca _rootDir = PathUtils.NormalizePathAndTrim(_rootDir); } - Version.TryParse(@params.initializationOptions.interpreter.properties?.Version, out var version); + var interpreterVersionString = @params.initializationOptions.interpreter.properties?.Version; + if (string.IsNullOrEmpty(interpreterVersionString)) { + _log?.Log(TraceEventType.Warning, Resources.PythonInterpreterVersionNotSpecified); + interpreterVersionString = "3.7"; + } + Version.TryParse(interpreterVersionString, out var version); - var configuration = new InterpreterConfiguration(null, null, + var configuration = new InterpreterConfiguration( interpreterPath: @params.initializationOptions.interpreter.properties?.InterpreterPath, version: version ) { @@ -139,8 +143,11 @@ public async Task InitializeAsync(InitializeParams @params, Ca TypeshedPath = @params.initializationOptions.typeStubSearchPaths.FirstOrDefault() }; - if (@params.initializationOptions.enableAnalysCache != false) { + if (@params.initializationOptions.enableAnalysisCache != false) { + _log?.Log(TraceEventType.Information, Resources.AnalysisCacheEnabled); _services.AddService(new ModuleDatabase(_services)); + } else { + _log?.Log(TraceEventType.Information, Resources.AnalysisCacheDisabled); } _interpreter = await PythonInterpreter.CreateAsync(configuration, _rootDir, _services, cancellationToken); @@ -184,9 +191,9 @@ public void DidChangeConfiguration(DidChangeConfigurationParams @params, Cancell _disposableBag.ThrowIfDisposed(); switch (@params.settings) { case ServerSettings settings: { - if (HandleConfigurationChanges(settings)) { - RestartAnalysis(); - } + Settings = settings; + _symbolHierarchyMaxSymbols = Settings.analysis.symbolsHierarchyMaxSymbols; + _completionSource.Options = Settings.completion; break; } default: @@ -205,27 +212,6 @@ private void DisplayStartupInfo() { : Resources.InitializingForPythonInterpreter.FormatInvariant(_interpreter.Configuration.InterpreterPath)); } - private bool HandleConfigurationChanges(ServerSettings newSettings) { - var oldSettings = Settings; - Settings = newSettings; - - _symbolHierarchyMaxSymbols = Settings.analysis.symbolsHierarchyMaxSymbols; - _completionSource.Options = Settings.completion; - - if (oldSettings == null) { - return true; - } - - if (!newSettings.analysis.errors.SetEquals(oldSettings.analysis.errors) || - !newSettings.analysis.warnings.SetEquals(oldSettings.analysis.warnings) || - !newSettings.analysis.information.SetEquals(oldSettings.analysis.information) || - !newSettings.analysis.disabled.SetEquals(oldSettings.analysis.disabled)) { - return true; - } - - return false; - } - private IDocumentationSource ChooseDocumentationSource(string[] kinds) { if (kinds == null) { return new PlainTextDocumentationSource(); @@ -267,33 +253,21 @@ private void ResetPathWatcher() { if (_searchPaths == null || !_searchPaths.SequenceEqual(paths)) { _searchPaths = paths; _pathsWatcher?.Dispose(); - _pathsWatcher = new PathsWatcher(_searchPaths, () => NotifyPackagesChanged(), _log); + _pathsWatcher = new PathsWatcher(_searchPaths, NotifyPackagesChanged, _log); } } - public void NotifyPackagesChanged(CancellationToken cancellationToken = default) { - var interpreter = _services.GetService(); + private void NotifyPackagesChanged() { _log?.Log(TraceEventType.Information, Resources.ReloadingModules); - // No need to reload typeshed resolution since it is a static storage. - // User does can add stubs while application is running, but it is - // by design at this time that the app should be restarted. - interpreter.ModuleResolution.ReloadAsync(cancellationToken).ContinueWith(t => { - _log?.Log(TraceEventType.Information, Resources.Done); - _log?.Log(TraceEventType.Information, Resources.AnalysisRestarted); - RestartAnalysis(); - + _services.GetService().ResetAnalyzer().ContinueWith(t => { if (_watchSearchPaths) { ResetPathWatcher(); } - }, cancellationToken).DoNotWait(); - } - - private void RestartAnalysis() { - var analyzer = Services.GetService(); - analyzer.ResetAnalyzer(); - _rdt.ReloadAll(); + _log?.Log(TraceEventType.Information, Resources.Done); + _log?.Log(TraceEventType.Information, Resources.AnalysisRestarted); + }).DoNotWait(); } } } diff --git a/src/LanguageServer/Impl/Indexing/MostRecentDocumentSymbols.cs b/src/LanguageServer/Impl/Indexing/MostRecentDocumentSymbols.cs index 2096e26fc..fe8b6969b 100644 --- a/src/LanguageServer/Impl/Indexing/MostRecentDocumentSymbols.cs +++ b/src/LanguageServer/Impl/Indexing/MostRecentDocumentSymbols.cs @@ -7,6 +7,7 @@ using Microsoft.Python.Analysis.Documents; using Microsoft.Python.Core; using Microsoft.Python.Core.Diagnostics; +using Microsoft.Python.Parsing.Ast; namespace Microsoft.Python.LanguageServer.Indexing { class MostRecentDocumentSymbols : IMostRecentDocumentSymbols { @@ -120,7 +121,20 @@ public void Dispose() { } private async Task> IndexAsync(IDocument doc, CancellationToken indexCt) { - var ast = await doc.GetAstAsync(indexCt); + PythonAst ast = null; + + for (var i = 0; i < 5; i++) { + ast = await doc.GetAstAsync(indexCt); + if (ast != null) { + break; + } + await Task.Delay(100); + } + + if (ast == null) { + return Array.Empty(); + } + indexCt.ThrowIfCancellationRequested(); var walker = new SymbolIndexWalker(ast); ast.Walk(walker); diff --git a/src/LanguageServer/Impl/LanguageServer.Configuration.cs b/src/LanguageServer/Impl/LanguageServer.Configuration.cs index 1129c6a83..1ac34b14a 100644 --- a/src/LanguageServer/Impl/LanguageServer.Configuration.cs +++ b/src/LanguageServer/Impl/LanguageServer.Configuration.cs @@ -36,7 +36,9 @@ public async Task DidChangeConfiguration(JToken token, CancellationToken cancell using (await _prioritizer.ConfigurationPriorityAsync(cancellationToken)) { var settings = new LanguageServerSettings(); - var rootSection = token["settings"]; + // https://github.com/microsoft/python-language-server/issues/915 + // If token or settings are missing, assume defaults. + var rootSection = token?["settings"]; var pythonSection = rootSection?["python"]; if (pythonSection == null) { return; diff --git a/src/LanguageServer/Impl/Protocol/Classes.cs b/src/LanguageServer/Impl/Protocol/Classes.cs index 6d8e7ec31..0359ed96c 100644 --- a/src/LanguageServer/Impl/Protocol/Classes.cs +++ b/src/LanguageServer/Impl/Protocol/Classes.cs @@ -162,7 +162,7 @@ public sealed class InterpreterProperties { /// /// Turns off analysis caching. /// - public bool? enableAnalysCache; + public bool? enableAnalysisCache; } [Serializable] diff --git a/src/LanguageServer/Impl/Resources.Designer.cs b/src/LanguageServer/Impl/Resources.Designer.cs index b832d5839..135b8a537 100644 --- a/src/LanguageServer/Impl/Resources.Designer.cs +++ b/src/LanguageServer/Impl/Resources.Designer.cs @@ -19,7 +19,7 @@ namespace Microsoft.Python.LanguageServer { // class via a tool like ResGen or Visual Studio. // To add or remove a member, edit your .ResX file then rerun ResGen // with the /str option, or rebuild your VS project. - [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] internal class Resources { @@ -60,6 +60,24 @@ internal Resources() { } } + /// + /// Looks up a localized string similar to Analysis cache disabled.. + /// + internal static string AnalysisCacheDisabled { + get { + return ResourceManager.GetString("AnalysisCacheDisabled", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Analysis cache enabled.. + /// + internal static string AnalysisCacheEnabled { + get { + return ResourceManager.GetString("AnalysisCacheEnabled", resourceCulture); + } + } + /// /// Looks up a localized string similar to Code analysis is in progress.... /// @@ -132,6 +150,15 @@ internal static string LineFormatter_UnmatchedToken { } } + /// + /// Looks up a localized string similar to Python interpreter version not specified. Assuming latests 3.x.. + /// + internal static string PythonInterpreterVersionNotSpecified { + get { + return ResourceManager.GetString("PythonInterpreterVersionNotSpecified", resourceCulture); + } + } + /// /// Looks up a localized string similar to Reloading modules... . /// diff --git a/src/LanguageServer/Impl/Resources.resx b/src/LanguageServer/Impl/Resources.resx index 3a720034d..2e2f7bb58 100644 --- a/src/LanguageServer/Impl/Resources.resx +++ b/src/LanguageServer/Impl/Resources.resx @@ -117,6 +117,12 @@ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + Analysis cache disabled. + + + Analysis cache enabled. + Code analysis is in progress... @@ -141,6 +147,9 @@ Unmatched token '{0}' on line {1}; line formatting may not be accurate. + + Python interpreter version not specified. Assuming latests 3.x. + Reloading modules... diff --git a/src/LanguageServer/Impl/Sources/DefinitionSource.cs b/src/LanguageServer/Impl/Sources/DefinitionSource.cs index a00579b4f..7a52c8b75 100644 --- a/src/LanguageServer/Impl/Sources/DefinitionSource.cs +++ b/src/LanguageServer/Impl/Sources/DefinitionSource.cs @@ -193,7 +193,7 @@ private Reference TryFromVariable(string name, IDocumentAnalysis analysis, Sourc definingMember = null; var m = analysis.ExpressionEvaluator.LookupNameInScopes(name, out var scope); - if (m == null || !(scope.Variables[name] is IVariable v)) { + if (m == null || scope.Module.ModuleType == ModuleType.Builtins || !(scope.Variables[name] is IVariable v)) { return null; } @@ -283,7 +283,8 @@ private bool CanNavigateToModule(Uri uri) { } private static bool CanNavigateToModule(IPythonModule m) - => m?.ModuleType == ModuleType.Stub || + => m?.ModuleType == ModuleType.User || + m?.ModuleType == ModuleType.Stub || m?.ModuleType == ModuleType.Package || m?.ModuleType == ModuleType.Library || m?.ModuleType == ModuleType.Specialized; diff --git a/src/Parsing/Test/PythonInstallPathResolver.cs b/src/Parsing/Test/PythonInstallPathResolver.cs index 31676648e..37fae5fb2 100644 --- a/src/Parsing/Test/PythonInstallPathResolver.cs +++ b/src/Parsing/Test/PythonInstallPathResolver.cs @@ -37,6 +37,5 @@ public static class PythonInstallPathResolver { public interface IPythonInstallPathResolver { InterpreterConfiguration GetCorePythonConfiguration(InterpreterArchitecture architecture, Version version); InterpreterConfiguration GetCondaPythonConfiguration(InterpreterArchitecture architecture, Version version); - InterpreterConfiguration GetIronPythonConfiguration(bool x64); } } diff --git a/src/Parsing/Test/PythonVersion.cs b/src/Parsing/Test/PythonVersion.cs index a0d7be0ac..612db44f4 100644 --- a/src/Parsing/Test/PythonVersion.cs +++ b/src/Parsing/Test/PythonVersion.cs @@ -25,11 +25,9 @@ public PythonVersion(InterpreterConfiguration config, bool cPython = false) { IsCPython = cPython; } - public override string ToString() => Configuration.Description; public string LibraryPath => Configuration.LibraryPath; public string InterpreterPath => Configuration.InterpreterPath; public PythonLanguageVersion Version => Configuration.Version.ToLanguageVersion(); - public string Id => Configuration.Id; public bool Isx64 => Configuration.Architecture == InterpreterArchitecture.x64; public InterpreterArchitecture Architecture => Configuration.Architecture; } diff --git a/src/Parsing/Test/PythonVersions.cs b/src/Parsing/Test/PythonVersions.cs index 771aef56b..a199eba79 100644 --- a/src/Parsing/Test/PythonVersions.cs +++ b/src/Parsing/Test/PythonVersions.cs @@ -26,7 +26,6 @@ public static class PythonVersions { public static readonly InterpreterConfiguration Python36 = GetCPythonVersion(PythonLanguageVersion.V36, InterpreterArchitecture.x86); public static readonly InterpreterConfiguration Python37 = GetCPythonVersion(PythonLanguageVersion.V37, InterpreterArchitecture.x86); public static readonly InterpreterConfiguration Python38 = GetCPythonVersion(PythonLanguageVersion.V38, InterpreterArchitecture.x86); - public static readonly InterpreterConfiguration IronPython27 = GetIronPythonVersion(false); public static readonly InterpreterConfiguration Python27_x64 = GetCPythonVersion(PythonLanguageVersion.V27, InterpreterArchitecture.x64); public static readonly InterpreterConfiguration Python35_x64 = GetCPythonVersion(PythonLanguageVersion.V35, InterpreterArchitecture.x64); public static readonly InterpreterConfiguration Python36_x64 = GetCPythonVersion(PythonLanguageVersion.V36, InterpreterArchitecture.x64); @@ -38,8 +37,6 @@ public static class PythonVersions { public static readonly InterpreterConfiguration Anaconda36_x64 = GetAnacondaVersion(PythonLanguageVersion.V36, InterpreterArchitecture.x64); public static readonly InterpreterConfiguration Anaconda37 = GetAnacondaVersion(PythonLanguageVersion.V37, InterpreterArchitecture.x86); public static readonly InterpreterConfiguration Anaconda37_x64 = GetAnacondaVersion(PythonLanguageVersion.V37, InterpreterArchitecture.x64); - public static readonly InterpreterConfiguration IronPython27_x64 = GetIronPythonVersion(true); - public static readonly InterpreterConfiguration Jython27 = GetJythonVersion(PythonLanguageVersion.V27); public static IEnumerable AnacondaVersions => GetVersions( Anaconda36, @@ -52,8 +49,6 @@ public static class PythonVersions { public static IEnumerable Versions => GetVersions( Python27, Python27_x64, - IronPython27, - IronPython27_x64, Python35, Python35_x64, Python36, @@ -61,7 +56,7 @@ public static class PythonVersions { Python37, Python37_x64, Python38, - Python38_x64, Jython27); + Python38_x64); public static InterpreterConfiguration Required_Python27X => Python27 ?? Python27_x64 ?? NotInstalled("v2.7"); public static InterpreterConfiguration Required_Python35X => Python35 ?? Python35_x64 ?? NotInstalled("v3.5"); @@ -122,50 +117,6 @@ private static InterpreterConfiguration GetCPythonVersion(PythonLanguageVersion private static InterpreterConfiguration GetAnacondaVersion(PythonLanguageVersion version, InterpreterArchitecture arch) => PythonInstallPathResolver.Instance.GetCondaPythonConfiguration(arch, version.ToVersion()); - private static InterpreterConfiguration GetIronPythonVersion(bool x64) { - return PythonInstallPathResolver.Instance.GetIronPythonConfiguration(x64); - } - - private static InterpreterConfiguration GetJythonVersion(PythonLanguageVersion version) { - var candidates = new List(); - var ver = version.ToVersion(); - var path1 = string.Format("jython{0}{1}*", ver.Major, ver.Minor); - var path2 = string.Format("jython{0}.{1}*", ver.Major, ver.Minor); - - foreach (var drive in DriveInfo.GetDrives()) { - if (drive.DriveType != DriveType.Fixed) { - continue; - } - - try { - candidates.AddRange(drive.RootDirectory.EnumerateDirectories(path1)); - candidates.AddRange(drive.RootDirectory.EnumerateDirectories(path2)); - } catch { - } - } - - foreach (var dir in candidates) { - var interpreter = dir.EnumerateFiles("jython.bat").FirstOrDefault(); - if (interpreter == null) { - continue; - } - - var libPath = dir.EnumerateDirectories("Lib").FirstOrDefault(); - if (libPath == null || !libPath.EnumerateFiles("site.py").Any()) { - continue; - } - - return new InterpreterConfiguration( - id: $"Global|Jython|{version.ToVersion()}", - description: string.Format("Jython {0}", version.ToVersion()), - interpreterPath: interpreter.FullName, - version: version.ToVersion() - ); - } - - return null; - } - private static InterpreterConfiguration NotInstalled(string version) { Assert.Inconclusive($"Python interpreter {version} is not installed"); return null; diff --git a/src/Parsing/Test/UnixPythonInstallPathResolver.cs b/src/Parsing/Test/UnixPythonInstallPathResolver.cs index 1cdf77605..4931a52b7 100644 --- a/src/Parsing/Test/UnixPythonInstallPathResolver.cs +++ b/src/Parsing/Test/UnixPythonInstallPathResolver.cs @@ -40,8 +40,6 @@ public InterpreterConfiguration GetCorePythonConfiguration(InterpreterArchitectu public InterpreterConfiguration GetCondaPythonConfiguration(InterpreterArchitecture architecture, Version version) => architecture == InterpreterArchitecture.x86 ? null : _condaCache.TryGetValue(version, out var interpreterConfiguration) ? interpreterConfiguration : null; - public InterpreterConfiguration GetIronPythonConfiguration(bool x64) => null; - private void GetConfigurationsFromKnownPaths() { var homePath = Environment.GetEnvironmentVariable("HOME"); var foldersFromPathVariable = Environment.GetEnvironmentVariable("PATH")?.Split(':') ?? Array.Empty(); @@ -90,8 +88,6 @@ private InterpreterConfiguration GetConfiguration(string idPrefix, string python var sitePackagesPath = GetSitePackagesLocation(pythonFilePath); return new InterpreterConfiguration( - id: $"{idPrefix}|{version}", - description: $"{idPrefix} {version} ({architecture})", interpreterPath: pythonFilePath, pathVar: pythonFilePath, libPath: libPath, diff --git a/src/Parsing/Test/WindowsPythonInstallPathResolver.cs b/src/Parsing/Test/WindowsPythonInstallPathResolver.cs index 9ec3a57fe..2a77e4ded 100644 --- a/src/Parsing/Test/WindowsPythonInstallPathResolver.cs +++ b/src/Parsing/Test/WindowsPythonInstallPathResolver.cs @@ -40,34 +40,9 @@ public InterpreterConfiguration GetCondaPythonConfiguration(InterpreterArchitect private InterpreterConfiguration GetPythonConfiguration(string prefix, InterpreterArchitecture architecture, Version version) => _registryCache.FirstOrDefault(configuration => - configuration.Id.StartsWith(prefix) && configuration.Architecture == architecture && configuration.Version == version); - public InterpreterConfiguration GetIronPythonConfiguration(bool x64) { - var installPath = GetIronPythonInstallDir(); - if (!Directory.Exists(installPath)) { - return null; - } - - var exeName = x64 ? "ipy64.exe" : "ipy.exe"; - // IronPython changed to Any CPU for ipy.exe and ipy32.exe for 32-bit in 2.7.8 - if (File.Exists(Path.Combine(installPath, "ipy32.exe"))) { - exeName = x64 ? "ipy.exe" : "ipy32.exe"; - } - - return new InterpreterConfiguration( - id: x64 ? "IronPython|2.7-64" : "IronPython|2.7-32", - description: string.Format("IronPython {0} 2.7", x64 ? "64-bit" : "32-bit"), - interpreterPath: Path.Combine(installPath, exeName), - libPath: Path.Combine(installPath, "Lib"), - sitePackagesPath: Path.Combine(installPath, "Lib", "site-packages"), - architecture: x64 ? InterpreterArchitecture.x64 : InterpreterArchitecture.x86, - version: new Version(2, 7), - pathVar: "IRONPYTHONPATH" - ); - } - private List FindPythonConfigurationsInRegistry() { var configurations = new List(); @@ -87,7 +62,6 @@ private List FindPythonConfigurationsInRegistry() { } } - InterpreterConfiguration.DisambiguateDescriptions(configurations); return configurations; } @@ -183,16 +157,8 @@ InterpreterArchitecture assumedArchitecture } var pathVar = tagKey.GetValue("PathEnvironmentVariable") as string ?? "PYTHONPATH"; - var id = $"Global|{company}|{tag}"; - - var description = tagKey.GetValue("DisplayName") as string; - if (string.IsNullOrEmpty(description)) { - description = pythonCoreCompatibility ? "Python {0}{1: ()}".FormatUI(version, architecture) : "{0} {1}".FormatUI(company, tag); - } return new InterpreterConfiguration( - id: id, - description: description, interpreterPath: exePath, pathVar: pathVar, libPath: Path.Combine(prefixPath, "Lib"),