gitnexus 1.6.13-rc.53 → 1.6.13-rc.55

package/dist/core/ingestion/languages/python/builtin-descriptors.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Decide whether a method decorator names one of Python's builtin descriptor
+ * types, following CPython's evaluation of the decorator expression.
+ *
+ * A decorator in a class body is evaluated with LOAD_NAME: the class
+ * namespace first, then module globals, then builtins, each as bound at the
+ * moment the `def` statement runs. Aliases, dotted names and decorator calls
+ * have no known descriptor contract without import resolution, so only bare
+ * spellings qualify.
+ */
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+declare const BUILTIN_DESCRIPTOR_NAMES: readonly ['classmethod', 'staticmethod', 'property'];
+export type BuiltinDescriptor = (typeof BUILTIN_DESCRIPTOR_NAMES)[number];
+/** Decorator expressions, outermost first. Tree-sitter keeps a trailing
+ *  comment inside the decorator node, so read the expression child only. */
+export declare function decoratorNames(fnNode: SyntaxNode): string[];
+/** Does `expression` denote a builtin descriptor type (or `kind`) at `fnNode`? */
+export declare function isBuiltinDescriptor(fnNode: SyntaxNode, expression: string, kind?: BuiltinDescriptor): boolean;
+export {};

package/dist/core/ingestion/languages/python/builtin-descriptors.js

@@ -0,0 +1,314 @@
+/**
+ * Decide whether a method decorator names one of Python's builtin descriptor
+ * types, following CPython's evaluation of the decorator expression.
+ *
+ * A decorator in a class body is evaluated with LOAD_NAME: the class
+ * namespace first, then module globals, then builtins, each as bound at the
+ * moment the `def` statement runs. Aliases, dotted names and decorator calls
+ * have no known descriptor contract without import resolution, so only bare
+ * spellings qualify.
+ */
+const BUILTIN_DESCRIPTOR_NAMES = ['classmethod', 'staticmethod', 'property'];
+const BUILTIN_DESCRIPTORS = new Set(BUILTIN_DESCRIPTOR_NAMES);
+/** Decorator expressions, outermost first. Tree-sitter keeps a trailing
+ *  comment inside the decorator node, so read the expression child only. */
+export function decoratorNames(fnNode) {
+    const parent = fnNode.parent;
+    if (parent === null || parent.type !== 'decorated_definition')
+        return [];
+    const names = [];
+    for (const child of parent.namedChildren) {
+        if (child.type !== 'decorator')
+            continue;
+        // An empty name matches nothing, so a malformed decorator stays unknown.
+        names.push(child.namedChildren.find((part) => part.type !== 'comment')?.text ?? '');
+    }
+    return names;
+}
+/** Does `expression` denote a builtin descriptor type (or `kind`) at `fnNode`? */
+export function isBuiltinDescriptor(fnNode, expression, kind) {
+    if (kind === undefined ? !BUILTIN_DESCRIPTORS.has(expression) : expression !== kind)
+        return false;
+    // Decorators are evaluated as the `def` statement runs, so its wrapper is the
+    // use site. No statement can rebind the name between stacked decorators.
+    const use = fnNode.parent?.type === 'decorated_definition' ? fnNode.parent : fnNode;
+    return lookupName(descriptorBindings(fnNode).get(expression) ?? [], use) !== 'shadow';
+}
+const FUNCTION_SCOPES = new Set(['function_definition', 'lambda']);
+const COMPREHENSIONS = new Set([
+    'list_comprehension',
+    'set_comprehension',
+    'dictionary_comprehension',
+    'generator_expression',
+]);
+const TARGET_WRAPPERS = new Set([
+    'pattern_list',
+    'tuple_pattern',
+    'list_pattern',
+    'list_splat_pattern',
+    'dictionary_splat_pattern',
+    'as_pattern_target',
+    'expression_list',
+    'parenthesized_expression',
+]);
+/** Simple statements whose effect always happens once execution reaches them. */
+const SIMPLE_STATEMENTS = new Set([
+    'expression_statement',
+    'import_statement',
+    'import_from_statement',
+    'delete_statement',
+]);
+/** Is `node` the `field` child of its parent? */
+function isField(node, field) {
+    return node.parent?.childForFieldName(field)?.id === node.id;
+}
+/** Does `statement` import from the `builtins` module? */
+function importsFromBuiltins(statement) {
+    return statement?.childForFieldName('module_name')?.text === 'builtins';
+}
+/**
+ * The binding this identifier performs, following the binding constructs of
+ * Language Reference 4.2.1, or `null` for a plain read.
+ */
+function bindingOf(identifier) {
+    let node = identifier;
+    let parent = node.parent;
+    while (parent !== null && TARGET_WRAPPERS.has(parent.type)) {
+        node = parent;
+        parent = node.parent;
+    }
+    if (parent === null)
+        return null;
+    const shadow = { node: identifier, effect: 'shadow' };
+    switch (parent.type) {
+        case 'assignment':
+        case 'augmented_assignment':
+        case 'for_statement':
+        case 'for_in_clause':
+            return isField(node, 'left') ? shadow : null;
+        case 'named_expression':
+        case 'function_definition':
+        case 'class_definition':
+        case 'default_parameter':
+        case 'typed_default_parameter':
+            return isField(node, 'name') ? shadow : null;
+        case 'as_pattern':
+            return isField(node, 'alias') ? shadow : null;
+        case 'aliased_import': {
+            if (!isField(node, 'alias'))
+                return null;
+            // `from builtins import staticmethod as staticmethod` binds the builtin.
+            const source = parent.childForFieldName('name')?.text;
+            return importsFromBuiltins(parent.parent) && source === identifier.text
+                ? { node: identifier, effect: 'builtin' }
+                : shadow;
+        }
+        case 'typed_parameter':
+            return node.type === 'identifier' ? shadow : null;
+        case 'parameters':
+        case 'lambda_parameters':
+            return shadow;
+        case 'delete_statement':
+            return { node: identifier, effect: 'unbind' };
+        case 'type':
+            return parent.parent?.type === 'type_parameter' ||
+                (parent.parent?.type === 'type_alias_statement' && isField(parent, 'left'))
+                ? shadow
+                : null;
+        case 'dotted_name': {
+            const owner = parent.parent;
+            // `import a.b` binds `a`; `case name:` captures a single name.
+            if (owner?.type === 'import_statement')
+                return parent.firstNamedChild?.id === node.id ? shadow : null;
+            if (owner?.type === 'case_pattern')
+                return parent.namedChildCount === 1 ? shadow : null;
+            if (owner?.type !== 'import_from_statement' || !isField(parent, 'name'))
+                return null;
+            return importsFromBuiltins(owner) ? { node: identifier, effect: 'builtin' } : shadow;
+        }
+        default:
+            return null;
+    }
+}
+const bindingsByTree = new WeakMap();
+/** Every binding of a builtin descriptor name in the file, in source order. */
+function descriptorBindings(node) {
+    const tree = node.tree;
+    const cached = bindingsByTree.get(tree);
+    if (cached !== undefined)
+        return cached;
+    // `global x` / `nonlocal x` bind nothing themselves; they redirect the
+    // declaring scope's own bindings of `x` to an outer namespace.
+    const redirected = new Map();
+    for (const statement of tree.rootNode.descendantsOfType([
+        'global_statement',
+        'nonlocal_statement',
+    ])) {
+        const scope = scopeOf(statement)?.id;
+        const kind = statement.type === 'global_statement' ? 'global' : 'nonlocal';
+        for (const name of statement.namedChildren)
+            redirected.set(`${name.text}@${scope}`, kind);
+    }
+    const bindings = new Map();
+    const add = (name, binding) => {
+        const list = bindings.get(name);
+        if (list === undefined)
+            bindings.set(name, [binding]);
+        else
+            list.push(binding);
+    };
+    for (const found of tree.rootNode.descendantsOfType(['identifier', 'wildcard_import'])) {
+        if (found.type === 'wildcard_import') {
+            // `from m import *` binds every public name m defines. Unless m is
+            // `builtins`, whether that includes a descriptor name is unknown here.
+            const effect = importsFromBuiltins(found.parent) ? 'builtin' : 'shadow';
+            for (const name of BUILTIN_DESCRIPTORS)
+                add(name, { node: found, effect, redirect: null });
+            continue;
+        }
+        if (!BUILTIN_DESCRIPTORS.has(found.text))
+            continue;
+        const binding = bindingOf(found);
+        if (binding === null)
+            continue;
+        const redirect = redirected.get(`${found.text}@${scopeOf(found)?.id}`) ?? null;
+        add(found.text, { ...binding, redirect });
+    }
+    bindingsByTree.set(tree, bindings);
+    return bindings;
+}
+/**
+ * The scope that owns names bound at `node`: a function or lambda body, a
+ * class body, a comprehension, or the module (`null`). A walrus target skips
+ * comprehensions, as PEP 572 binds it in the enclosing scope.
+ */
+function scopeOf(node) {
+    const skipComprehensions = node.parent?.type === 'named_expression';
+    let child = node;
+    for (let parent = node.parent; parent !== null; child = parent, parent = parent.parent) {
+        if (FUNCTION_SCOPES.has(parent.type)) {
+            if (isField(child, 'body') || isField(child, 'parameters'))
+                return parent;
+        }
+        else if (parent.type === 'class_definition') {
+            if (isField(child, 'body'))
+                return parent;
+        }
+        else if (COMPREHENSIONS.has(parent.type) && !skipComprehensions) {
+            return parent;
+        }
+    }
+    return null;
+}
+/** The statement containing `node` that sits directly in `body`. */
+function statementIn(node, body) {
+    let current = node;
+    while (current.parent !== null && current.parent.id !== body.id)
+        current = current.parent;
+    return current.parent === null ? null : current;
+}
+/** Can `binding` run before `use` in the same scope, including an earlier
+ *  iteration of an enclosing loop? */
+function mayRunBefore(binding, use, scope) {
+    if (binding.startIndex < use.startIndex)
+        return true;
+    for (let loop = use.parent; loop !== null && loop.id !== scope?.id; loop = loop.parent) {
+        if ((loop.type === 'for_statement' || loop.type === 'while_statement') &&
+            binding.startIndex >= loop.startIndex &&
+            binding.endIndex <= loop.endIndex) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * What a module, class or function namespace holds for the name when
+ * execution reaches `use`. A `shadow` that may have run wins. A restoring
+ * effect (`builtin`, `unbind`) counts only when it is a simple statement
+ * directly in the scope body that runs before `use`, so it runs exactly once
+ * in order.
+ */
+function namespaceState(bindings, scope, use) {
+    const body = scope === null ? null : scope.childForFieldName('body');
+    let state = 'unbind';
+    for (const binding of bindings) {
+        if (binding.redirect !== null || scopeOf(binding.node)?.id !== scope?.id)
+            continue;
+        if (!mayRunBefore(binding.node, use, scope))
+            continue;
+        if (binding.effect === 'shadow') {
+            state = 'shadow';
+            continue;
+        }
+        const statement = statementIn(binding.node, body ?? binding.node.tree.rootNode);
+        const ordered = binding.node.startIndex < use.startIndex;
+        if (ordered && statement !== null && SIMPLE_STATEMENTS.has(statement.type)) {
+            state = binding.effect;
+        }
+    }
+    return state;
+}
+/**
+ * Resolve the decorator name at `use` as a class body does (Language
+ * Reference 4.2.2): the class namespace first, then the innermost enclosing
+ * function that binds the name, then module globals, then builtins.
+ */
+function lookupName(bindings, use) {
+    // Enclosing scopes, innermost first, ending with the module (`null`).
+    const chain = [];
+    for (let scope = scopeOf(use); scope !== null; scope = scopeOf(scope))
+        chain.push(scope);
+    chain.push(null);
+    const classScope = chain[0]?.type === 'class_definition' ? chain[0] : null;
+    if (classScope !== null) {
+        const state = namespaceState(bindings, classScope, use);
+        if (state !== 'unbind')
+            return state;
+    }
+    const functions = chain.filter((scope) => scope !== null && FUNCTION_SCOPES.has(scope.type));
+    for (const fn of functions) {
+        const owned = bindings.some((binding) => binding.redirect === null && scopeOf(binding.node)?.id === fn.id);
+        if (!owned)
+            continue;
+        // Any binding makes the name local to this function, so the class body
+        // reads that cell. An unbound cell raises NameError, not the builtin.
+        return namespaceState(bindings, fn, use) === 'builtin' ? 'builtin' : 'shadow';
+    }
+    // A class body inside a function runs whenever that function is called,
+    // which can be any time after its top-level statement starts. Module state
+    // is therefore read at that statement, and any later module override may
+    // also have run first.
+    const deferred = functions.length > 0;
+    const moduleUse = deferred ? (statementIn(use, use.tree.rootNode) ?? use) : use;
+    for (const binding of bindings) {
+        if (binding.effect !== 'shadow')
+            continue;
+        // A nested function can rebind an enclosing function's cell whenever it
+        // is called; that order is not modelled, so assume it ran.
+        if (binding.redirect === 'nonlocal') {
+            const outer = functions[functions.length - 1];
+            const inside = outer !== undefined &&
+                binding.node.startIndex >= outer.startIndex &&
+                binding.node.endIndex <= outer.endIndex;
+            if (inside)
+                return 'shadow';
+        }
+        if (binding.redirect === 'global') {
+            // The function can only be called once the top-level statement that
+            // defines it has run. Whether a call happens is unknown, so a restoring
+            // `global` delete is ignored and a rebinding one is assumed.
+            const top = statementIn(binding.node, binding.node.tree.rootNode);
+            if (deferred || (top !== null && mayRunBefore(top, use, null)))
+                return 'shadow';
+        }
+    }
+    if (deferred) {
+        const laterOverride = bindings.some((binding) => binding.effect === 'shadow' &&
+            binding.redirect === null &&
+            scopeOf(binding.node) === null &&
+            binding.node.startIndex > moduleUse.startIndex);
+        if (laterOverride)
+            return 'shadow';
+    }
+    return namespaceState(bindings, null, moduleUse);
+}

package/dist/core/ingestion/languages/python/receiver-binding.d.ts

@@ -13,6 +13,13 @@ import type { CaptureMatch } from '../../../../_shared/index.js';
 import { type SyntaxNode } from '../../utils/ast-helpers.js';
 /** Static-like descriptors do not inject an instance on attribute access. */
 export declare function isPythonStaticLikeMethod(fnNode: SyntaxNode): boolean;
+/**
+ * Can the method's parameter list prove its call shape? Only a plain function
+ * or one builtin `staticmethod` / `classmethod` wrapper qualifies. Any other
+ * decorator may replace the callable, and a descriptor stack can make it
+ * uncallable: `staticmethod(classmethod(f))` yields a classmethod object.
+ */
+export declare function hasPythonProvenCallShape(fnNode: SyntaxNode): boolean;
 export interface PythonBoundReceiver {
     readonly kind: 'instance' | 'class';
     readonly parameter: SyntaxNode;

package/dist/core/ingestion/languages/python/receiver-binding.js

@@ -10,6 +10,7 @@
  * awareness that Python's runtime depends on.
  */
 import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+import { decoratorNames, isBuiltinDescriptor } from './builtin-descriptors.js';
 /** Walk up to the enclosing `class_definition`, ignoring the immediate
  *  `decorated_definition` wrapper. Returns `null` when the function is
  *  free, lambda-bodied, or nested inside another function. */
@@ -27,31 +28,6 @@ function findEnclosingClassDefinition(node) {
 function classDefinitionName(classNode) {
     return classNode.childForFieldName('name')?.text ?? null;
 }
-/** Syntactic decorator expressions; aliases cannot be identified by spelling. */
-function decoratorNames(fnNode) {
-    const parent = fnNode.parent;
-    if (parent === null || parent.type !== 'decorated_definition')
-        return [];
-    const names = [];
-    for (let i = 0; i < parent.namedChildCount; i++) {
-        const child = parent.namedChild(i);
-        if (child === null || child.type !== 'decorator')
-            continue;
-        const text = child.text.replace(/^@/, '').trim();
-        names.push(text);
-    }
-    return names;
-}
-/** Matches bare and module-qualified decorator spellings. */
-function hasDecorator(fnNode, decoratorName) {
-    return decoratorNames(fnNode).some((expression) => {
-        const name = expression.split('(')[0].trim();
-        return name === decoratorName || name.endsWith(`.${decoratorName}`);
-    });
-}
-// These spellings have a known descriptor contract in ordinary Python code.
-// Arbitrary dotted tails, aliases and decorator calls do not.
-const KNOWN_RECEIVER_DECORATORS = new Set(['classmethod', 'staticmethod', 'property']);
 /** Accept a local `@property` accessor chain, skipping only plain unrelated
  * methods. Other intervening class-suite statements may rebind the descriptor,
  * including tuple assignment or control flow. */
@@ -90,12 +66,12 @@ function isLocalPropertyAccessor(fnNode, expression) {
         }
         if (candidate?.childForFieldName('name')?.text !== methodName)
             return false;
-        const decorators = decoratorNames(candidate);
-        if (decorators.length !== 1)
+        const [decorator, ...rest] = decoratorNames(candidate);
+        if (decorator === undefined || rest.length > 0)
             return false;
-        if (decorators[0] === 'property')
+        if (isBuiltinDescriptor(candidate, decorator, 'property'))
             return true;
-        if (!['getter', 'setter', 'deleter'].some((kind) => decorators[0] === `${methodName}.${kind}`)) {
+        if (!['getter', 'setter', 'deleter'].some((kind) => decorator === `${methodName}.${kind}`)) {
             return false;
         }
     }
@@ -103,10 +79,25 @@ function isLocalPropertyAccessor(fnNode, expression) {
 }
 /** Static-like descriptors do not inject an instance on attribute access. */
 export function isPythonStaticLikeMethod(fnNode) {
-    return (fnNode.childForFieldName('name')?.text === '__new__' || hasDecorator(fnNode, 'staticmethod'));
+    return (fnNode.childForFieldName('name')?.text === '__new__' ||
+        decoratorNames(fnNode).some((name) => isBuiltinDescriptor(fnNode, name, 'staticmethod')));
+}
+/**
+ * Can the method's parameter list prove its call shape? Only a plain function
+ * or one builtin `staticmethod` / `classmethod` wrapper qualifies. Any other
+ * decorator may replace the callable, and a descriptor stack can make it
+ * uncallable: `staticmethod(classmethod(f))` yields a classmethod object.
+ */
+export function hasPythonProvenCallShape(fnNode) {
+    const [decorator, ...rest] = decoratorNames(fnNode);
+    if (decorator === undefined)
+        return true;
+    return (rest.length === 0 &&
+        (isBuiltinDescriptor(fnNode, decorator, 'staticmethod') ||
+            isBuiltinDescriptor(fnNode, decorator, 'classmethod')));
 }
 function isKnownReceiverDecorator(fnNode, expression) {
-    return KNOWN_RECEIVER_DECORATORS.has(expression) || isLocalPropertyAccessor(fnNode, expression);
+    return isBuiltinDescriptor(fnNode, expression) || isLocalPropertyAccessor(fnNode, expression);
 }
 function firstBoundReceiverParameter(parameters) {
     for (let i = 0; i < parameters.namedChildCount; i++) {
@@ -157,9 +148,6 @@ export function classifyPythonBoundReceiver(fnNode) {
         return null;
     }
     const functionName = fnNode.childForFieldName('name')?.text;
-    // Python applies these descriptor kinds implicitly even without decorators.
-    // __new__ is static-like (its class argument is explicit), while
-    // __init_subclass__ and __class_getitem__ receive the class implicitly.
     const params = fnNode.childForFieldName('parameters');
     if (params === null)
         return null;
@@ -171,6 +159,8 @@ export function classifyPythonBoundReceiver(fnNode) {
     if (name === null || className === null)
         return null;
     return {
+        // Python makes __init_subclass__ and __class_getitem__ implicit
+        // classmethods, so they receive the class even without a decorator.
         kind: decorators.includes('classmethod') ||
             functionName === '__init_subclass__' ||
             functionName === '__class_getitem__'
@@ -219,8 +209,10 @@ export function classifyPythonUncertainReceiver(fnNode) {
     // Python applies decorators bottom-up. An outer built-in staticmethod
     // guarantees no implicit receiver even when an inner decorator is opaque.
     // The first parameter remains explicit and can keep its annotation.
-    if (decorators[0] === 'staticmethod')
+    const outermost = decorators[0];
+    if (outermost !== undefined && isBuiltinDescriptor(fnNode, outermost, 'staticmethod')) {
         return null;
+    }
     if (decorators.every((name) => isKnownReceiverDecorator(fnNode, name)))
         return null;
     const enclosingClass = findEnclosingClassDefinition(fnNode);
@@ -342,8 +334,6 @@ export function synthesizeConstructorFieldTypeBindings(fnNode) {
         return [];
     if (findEnclosingClassDefinition(fnNode) === null)
         return [];
-    if (hasDecorator(fnNode, 'staticmethod') || hasDecorator(fnNode, 'classmethod'))
-        return [];
     const receiver = synthesizeReceiverTypeBinding(fnNode);
     const receiverName = receiver?.['@type-binding.self']?.text;
     if (receiverName === undefined)

package/dist/core/ingestion/languages/python/subtype-dispatch.js

@@ -1,5 +1,5 @@
 import { definitionIdPosition } from '../../scope-resolution/utils/definition-id.js';
-import { classifyPythonBoundReceiver, isPythonStaticLikeMethod } from './receiver-binding.js';
+import { classifyPythonBoundReceiver, hasPythonProvenCallShape, isPythonStaticLikeMethod, } from './receiver-binding.js';
 const simplePositionalCallsByFile = new Map();
 const positionalCapacitiesByFile = new Map();
 const positionKey = (line, column) => `${line}:${column}`;
@@ -87,19 +87,10 @@ function positionalCapacity(fnNode) {
 }
 /** Record a method's exact fixed positional capacity when the AST proves it. */
 export function recordPythonSubtypeMethodShape(filePath, fnNode, mapLine) {
-    // An unknown decorator may replace the function or mark it abstract.
-    // Positional shape alone cannot prove a concrete subtype dispatch target.
-    // The two built-in descriptor decorators are handled by receiver binding.
-    const wrapper = fnNode.parent;
-    if (wrapper?.type === 'decorated_definition' &&
-        wrapper.namedChildren.some((child) => {
-            if (child.type !== 'decorator')
-                return false;
-            const name = child.firstNamedChild?.text;
-            return name !== 'staticmethod' && name !== 'classmethod';
-        })) {
+    // An unknown decorator may replace the function or mark it abstract, so
+    // its parameter list cannot prove a concrete subtype dispatch target.
+    if (!hasPythonProvenCallShape(fnNode))
         return;
-    }
     const capacity = positionalCapacity(fnNode);
     if (capacity === undefined)
         return;

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.js

@@ -1892,9 +1892,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                                 if (picked === undefined) {
                                     // This runtime subtype has no proven binding. Preserve
                                     // partial coverage even when a sibling supplies a target.
-                                    if (!incompleteInheritanceSubtypeIds.has(subtype.nodeId)) {
-                                        missingMemberSubtypeIds.add(subtype.nodeId);
-                                    }
+                                    missingMemberSubtypeIds.add(subtype.nodeId);
                                     continue;
                                 }
                                 subtypeTargets.set(picked.nodeId, picked);

package/dist/storage/parse-cache.js

@@ -803,7 +803,11 @@ import { copyV8CacheIfPresent, tryLoadV8Cache, writeV8CacheFile } from './v8-sid
 // v120 (#3394): decorated Python method receiver bindings now distinguish
 // unproven decorators from instance receivers. Warm v119 ParsedFiles would
 // replay a fabricated `self` binding or lack the uncertainty marker entirely.
-const SCHEMA_BUMP = 120;
+// v121 (#3399 follow-up): Python decorator identity now ignores trailing
+// comments, honors rebinding of builtin descriptor names visible where the
+// decorator is evaluated, and withholds subtype capacity from descriptor
+// stacks. Warm v120 captures carry the old verdicts.
+const SCHEMA_BUMP = 121;
 const GITNEXUS_PKG_VERSION = (() => {
     try {
         // package.json sits at gitnexus/package.json — two levels up from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.13-rc.53",
+  "version": "1.6.13-rc.55",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",