code-intelligence 2.0.2__py3-none-win_amd64.whl → 3.0.1__py3-none-win_amd64.whl

code_intelligence/__init__.py

@@ -1,27 +1,18 @@
-from .symdb import (
+from .goober import (
     Language,
-    SymbolType,
-    Symbol,
-    SymbolLink,
-    Location,
-    ImmediateSymbolDatabase,
-    LazySymbolDatabase,
-    AsyncSymbolDatabase,
-    AsyncResult,
+    Definition_Link,
+    scan_file,
+    find_symbols_in_text,
+    stop,
 )
 
-__version__ = "2.0.2"
+__version__ = "3.0.1"
 __version_info__ = tuple(int(i) for i in __version__.split('.'))
 
 __all__ = [
     "Language",
-    "SymbolType",
-    "Symbol",
-    "SymbolLink",
-    "Location",
-    "ImmediateSymbolDatabase",
-    "LazySymbolDatabase",
-    "AsyncSymbolDatabase",
-    "AsyncResult",
-    "SymbolDatabase",
+    "Definition_Link",
+    "scan_file",
+    "find_symbols_in_text",
+    "stop",
 ]

code_intelligence/goober.py

@@ -0,0 +1,209 @@
+import ctypes as C
+import os
+import sys
+import time
+import threading
+from pathlib import Path
+from dataclasses import dataclass, fields
+from enum import IntEnum, IntFlag
+
+
+class Language(IntEnum):
+    UNKNOWN    = 0
+    PYTHON     = 1
+    JAVASCRIPT = 2
+
+
+DIR = Path(__file__).parent
+
+_lib = C.CDLL(str(DIR / "libcode_intelligence.so"))
+
+SCAN_CALLBACK = C.CFUNCTYPE(None, C.c_void_p)
+_lib.enqueue_scan_file.argtypes = [SCAN_CALLBACK, C.c_void_p, C.c_char_p, C.c_uint64]
+_lib.enqueue_scan_file.restype = None
+
+class Definition_Link_C(C.Structure):
+    _fields_ = [
+        ("start_offset_in_text", C.c_uint32),
+        ("end_offset_in_text"  , C.c_uint32),
+        ("source_file"         , C.c_char_p),
+        ("line_0_based"        , C.c_uint32),
+        ("column_0_based"      , C.c_uint32),
+    ]
+
+FIND_CALLBACK = C.CFUNCTYPE(None, C.c_void_p, C.POINTER(Definition_Link_C), C.c_int, C.c_void_p)
+_lib.enqueue_find_symbols_in_text.argtypes = [FIND_CALLBACK, C.c_void_p, C.c_char_p]
+_lib.enqueue_find_symbols_in_text.restype = None
+
+_lib.enqueue_stop.argtypes = []
+_lib.enqueue_stop.restype = None
+
+_lib.get_pending_tasks_count.argtypes = []
+_lib.get_pending_tasks_count.restype = C.c_uint64
+
+_lib.free_memory.argtypes = [C.c_void_p]
+_lib.free_memory.restype = None
+
+# --- CPYTHON C API ACCESS ---
+C.pythonapi.Py_IncRef.argtypes = [C.py_object]
+C.pythonapi.Py_IncRef.restype = None
+C.pythonapi.Py_DecRef.argtypes = [C.py_object]
+C.pythonapi.Py_DecRef.restype = None
+
+
+def positional_repr(cls):
+    def __repr__(self):
+        values = ', '.join(repr(getattr(self, f.name)) for f in fields(self))
+        return f"{cls.__name__}({values})"
+    cls.__repr__ = __repr__
+    return cls
+
+
+@dataclass
+@positional_repr
+class Definition_Link:
+    start_offset_in_text: int = 0
+    end_offset_in_text  : int = 0
+    source_file         : str = ""
+    line_0_based        : int = 0
+    column_0_based      : int = 0
+
+
+# IMPORTANT: KEEP THIS ALIVE FOR GO THREAD WORKER
+C_NO_CALLBACK = SCAN_CALLBACK(0)
+
+
+def _wrap_data_ptr(callback, data):
+    full_data = (callback, data)
+
+    # MANUALLY INCREMENT THE REFERENCE COUNT
+    # We are now responsible for its lifetime
+    C.pythonapi.Py_IncRef(full_data)
+
+    return id(full_data)
+
+
+def _unwrap_data_ptr(data_ptr):
+    assert data_ptr != 0, "we got NULL"
+
+    full_data = C.cast(data_ptr, C.py_object).value
+
+    # MANUALLY DECREMENT THE REFERENCE COUNT.
+    # We are fulfilling our promise
+    C.pythonapi.Py_DecRef(full_data)
+
+    return full_data
+
+
+def scan_file(file, language: Language, callback=None, data=None) -> bool:
+    if callback is None:
+        c_callback, data_ptr = C_NO_CALLBACK, 0
+    else:
+        c_callback, data_ptr = C_AFTER_SCAN, _wrap_data_ptr(callback, data)
+
+    # print(f"[PY] sending next request {file}")
+    _lib.enqueue_scan_file(c_callback, data_ptr, os.fsencode(file), language)
+
+    # never drop the request (it would be a memory leak)
+    return True
+
+
+@SCAN_CALLBACK
+def C_AFTER_SCAN(data_ptr):
+    callback, data = _unwrap_data_ptr(data_ptr)
+    if callback is not None:
+        callback(data)
+
+
+def find_symbols_in_text(text: str, callback=None, data=None) -> bool:
+    if callback is None:
+        c_callback, data_ptr = C_NO_CALLBACK, 0
+    else:
+        c_callback, data_ptr = C_AFTER_FIND, _wrap_data_ptr(callback, data)
+
+    # print("[PY] sending find_symbols_in_text")
+    _lib.enqueue_find_symbols_in_text(c_callback, data_ptr, text.encode())
+
+    # never drop the request (it would be a memory leak)
+    return True
+
+
+@FIND_CALLBACK
+def C_AFTER_FIND(data_ptr, links_ptr, count, strings_handle):
+    callback, data = _unwrap_data_ptr(data_ptr)
+    try:
+        if callback is not None:
+            results = [Definition_Link()] * count
+            for i in range(count):
+                link = links_ptr[i]
+                results[i] = Definition_Link(
+                    start_offset_in_text=link.start_offset_in_text,
+                    end_offset_in_text=link.end_offset_in_text,
+                    source_file=link.source_file.decode('utf-8'),
+                    line_0_based=link.line_0_based,
+                    column_0_based=link.column_0_based,
+                )
+            callback(data, results)
+    finally:
+        if links_ptr: _lib.free_memory(links_ptr)
+        if strings_handle: _lib.free_memory(strings_handle)
+
+
+def pending_tasks() -> int:
+    return _lib.get_pending_tasks_count()
+
+
+def stop():
+    _lib.enqueue_stop()
+
+
+def wait_for_callbacks_in_seconds(timeout_s, step_s=0.15):
+    # print(f"[PY] Waiting for callbacks (~{timeout_s}s)...")
+    deadline = time.time() + timeout_s
+    while True:
+        if pending_tasks() == 0:
+            # print("[PY] All pending tasks have completed.")
+            return True
+
+        if time.time() >= deadline:
+            print("[PY] Timeout reached.")
+            return False
+
+        # print(f"[PY] pending_tasks={pending_tasks()}")
+        time.sleep(step_s)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) <= 2:
+        print("usage: python goober.py text folder...")
+        exit(1)
+
+    def scan_callback(data):
+        print(f"[PY] {data}")
+
+    def find_callback(data, links):
+        text, label = data
+        print(f"[PY] Callback for '{label}': Found {len(links)} symbols in text \"{text}\"")
+        for res in links:
+            matched_symbol = text[res.start_offset_in_text:res.end_offset_in_text]
+            print(f"  '{matched_symbol}' -> {res.source_file}:{res.line_0_based}:{res.column_0_based}")
+
+    for folder in sys.argv[2:]:
+        path = Path(folder)
+        if path.is_dir():
+            for file in path.rglob("*.py"):
+                scan_file(file, scan_callback, file)
+        else:
+            scan_file(path, scan_callback, path)
+
+    text = sys.argv[1]
+    find_symbols_in_text(text, find_callback, data=(text, "before"))
+
+    print("[PY] WAIT, WAIT, WAIT!")
+    wait_for_callbacks_in_seconds(20)
+
+    find_symbols_in_text(text, find_callback, data=(text, "after"))
+
+    wait_for_callbacks_in_seconds(1)
+
+    stop()

code_intelligence/libcode_intelligence.h

@@ -0,0 +1,119 @@
+/* Code generated by cmd/cgo; DO NOT EDIT. */
+
+/* package code_intelligence/source */
+
+
+#line 1 "cgo-builtin-export-prolog"
+
+#include <stddef.h>
+
+#ifndef GO_CGO_EXPORT_PROLOGUE_H
+#define GO_CGO_EXPORT_PROLOGUE_H
+
+#ifndef GO_CGO_GOSTRING_TYPEDEF
+typedef struct { const char *p; ptrdiff_t n; } _GoString_;
+extern size_t _GoStringLen(_GoString_ s);
+extern const char *_GoStringPtr(_GoString_ s);
+#endif
+
+#endif
+
+/* Start of preamble from import "C" comments.  */
+
+
+#line 3 "main.go"
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdlib.h>
+
+typedef struct {
+    uint32_t start_offset_in_text;
+    uint32_t end_offset_in_text;
+    const char* source_file;
+    uint32_t line_0_based;
+    uint32_t column_0_based;
+} Definition_Link_C;
+
+typedef void (*scan_callback_t)(uintptr_t);
+typedef void (*find_callback_t)(uintptr_t, const Definition_Link_C*, int, void*);
+
+static inline void invoke_scan_callback(scan_callback_t callback, uintptr_t p) {
+    callback(p);
+}
+static inline void invoke_find_callback(find_callback_t callback, uintptr_t p, const Definition_Link_C* links, int count, void* string_handle) {
+    callback(p, links, count, string_handle);
+}
+
+
+#line 1 "cgo-generated-wrapper"
+
+
+/* End of preamble from import "C" comments.  */
+
+
+/* Start of boilerplate cgo prologue.  */
+#line 1 "cgo-gcc-export-header-prolog"
+
+#ifndef GO_CGO_PROLOGUE_H
+#define GO_CGO_PROLOGUE_H
+
+typedef signed char GoInt8;
+typedef unsigned char GoUint8;
+typedef short GoInt16;
+typedef unsigned short GoUint16;
+typedef int GoInt32;
+typedef unsigned int GoUint32;
+typedef long long GoInt64;
+typedef unsigned long long GoUint64;
+typedef GoInt64 GoInt;
+typedef GoUint64 GoUint;
+typedef size_t GoUintptr;
+typedef float GoFloat32;
+typedef double GoFloat64;
+#ifdef _MSC_VER
+#if !defined(__cplusplus) || _MSVC_LANG <= 201402L
+#include <complex.h>
+typedef _Fcomplex GoComplex64;
+typedef _Dcomplex GoComplex128;
+#else
+#include <complex>
+typedef std::complex<float> GoComplex64;
+typedef std::complex<double> GoComplex128;
+#endif
+#else
+typedef float _Complex GoComplex64;
+typedef double _Complex GoComplex128;
+#endif
+
+/*
+  static assertion to make sure the file is being used on architecture
+  at least with matching size of GoInt.
+*/
+typedef char _check_for_64_bit_pointer_matching_GoInt[sizeof(void*)==64/8 ? 1:-1];
+
+#ifndef GO_CGO_GOSTRING_TYPEDEF
+typedef _GoString_ GoString;
+#endif
+typedef void *GoMap;
+typedef void *GoChan;
+typedef struct { void *t; void *v; } GoInterface;
+typedef struct { void *data; GoInt len; GoInt cap; } GoSlice;
+
+#endif
+
+/* End of boilerplate cgo prologue.  */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern __declspec(dllexport) void enqueue_scan_file(scan_callback_t callback, uintptr_t data, char* c_path, GoUint64 language);
+extern __declspec(dllexport) void enqueue_find_symbols_in_text(find_callback_t callback, uintptr_t data, char* c_text);
+extern __declspec(dllexport) void enqueue_stop(void);
+extern __declspec(dllexport) GoUint64 get_pending_tasks_count(void);
+extern __declspec(dllexport) void free_memory(void* ptr);
+
+#ifdef __cplusplus
+}
+#endif

{code_intelligence-2.0.2.dist-info → code_intelligence-3.0.1.dist-info}/METADATA

@@ -1,4 +1,4 @@
 Metadata-Version: 2.1
 Name: code_intelligence
-Version: 2.0.2
+Version: 3.0.1
 Summary: Code intelligence library

code_intelligence-3.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+code_intelligence-3.0.1.dist-info/METADATA,sha256=ScA4qConScZC4WNjwdRekYeFFaDLAVRcFk1Y1nTNogY,100
+code_intelligence-3.0.1.dist-info/RECORD,,
+code_intelligence-3.0.1.dist-info/WHEEL,sha256=aD7J6E7Slys9i0J65v6Ehfi0DHYa5rImRhUDp62Iwh0,98
+code_intelligence/__init__.py,sha256=QPD-ZdurftMeM2nYpl6NVgnxjh-s-_E7q3n9eg3RgJo,327
+code_intelligence/goober.py,sha256=tX_P4EByTn6JXeUbrN1Su-eQt4EfblQwidjk5Wt9cMo,6217
+code_intelligence/libcode_intelligence.h,sha256=GN6gPx-vEG02Ltak29nGSX8rsxDlrjIkI-Tr_xBeet8,3059
+code_intelligence/libcode_intelligence.so,sha256=sJB2jhC1GH0V3umiQhpaKwtf6pSPja3aS0n2rgoLnR8,2827264
+code_intelligence/symdb.py,sha256=gRq3-xr2oYIzudgwDwMj3Zl5Pb0B8tDdnGKUB0WIV_o,32427

code_intelligence-2.0.2.dist-info/RECORD

@@ -1,6 +0,0 @@
-code_intelligence-2.0.2.dist-info/METADATA,sha256=8VQm-3UWGdDOH4xdvXuTAA16F--cu8OQ9nYQOvJqzSo,100
-code_intelligence-2.0.2.dist-info/RECORD,,
-code_intelligence-2.0.2.dist-info/WHEEL,sha256=aD7J6E7Slys9i0J65v6Ehfi0DHYa5rImRhUDp62Iwh0,98
-code_intelligence/__init__.py,sha256=JUcG5hLPvopKlYtD02xoEhoYzVImwWO-TJITknRZZGQ,527
-code_intelligence/_code_intelligence.dll,sha256=wFdz8sbeS2o-TR6RSWFYktcPlXMQI85HSPKcsH7-4LA,6662144
-code_intelligence/symdb.py,sha256=gRq3-xr2oYIzudgwDwMj3Zl5Pb0B8tDdnGKUB0WIV_o,32427