Add clj-kondo hook for require-python macro

- Add require_python.clj hook that transforms require-python calls
  into standard require forms that clj-kondo can analyze
- Strip libpython-specific flags: :bind-ns, :reload, :no-arglists
- Generate def forms for :bind-ns vars and :refer symbols
- Handle :refer with vectors, :all, or :*
- Support both v1 (libpython-clj.require) and v2 (libpython-clj2.require)
- Replace :lint-as approach with proper analyze-call hooks

This eliminates false positive "Unknown require option" warnings
for libpython-clj's Python interop macros.

Author: jjtolton

resources/clj-kondo.exports/clj-python/libpython-clj/config.edn

@@ -1,14 +1,16 @@
 {:hooks
  {:analyze-call {libpython-clj.jna.base/def-pylib-fn
                  hooks.libpython-clj.jna.base.def-pylib-fn/def-pylib-fn
+
                  libpython-clj.require/import-python
                  hooks.libpython-clj.require.import-python/import-python
                  libpython-clj2.require/import-python
-                 hooks.libpython-clj.require.import-python/import-python}}
+                 hooks.libpython-clj.require.import-python/import-python
 
- :lint-as
- {libpython-clj.require/require-python clojure.core/require
-  libpython-clj2.require/require-python clojure.core/require}
+                 libpython-clj.require/require-python
+                 hooks.libpython-clj.require.require-python/require-python
+                 libpython-clj2.require/require-python
+                 hooks.libpython-clj.require.require-python/require-python}}
 
  :linters
  {:unresolved-namespace

resources/clj-kondo.exports/clj-python/libpython-clj/hooks/libpython_clj/require/require_python.clj

@@ -0,0 +1,106 @@
+(ns hooks.libpython-clj.require.require-python
+  (:require [clj-kondo.hooks-api :as api]))
+
+(def ^:private libpython-unary-flags
+  #{:bind-ns :reload :no-arglists})
+
+(def ^:private libpython-binary-flags
+  #{:refer})
+
+(defn- get-sexpr [node]
+  (when node
+    (try
+      (api/sexpr node)
+      (catch Exception _ nil))))
+
+(defn- quoted-form?
+  [sexpr]
+  (and (seq? sexpr)
+       (= 'quote (first sexpr))))
+
+(defn- unquote-sexpr
+  [sexpr]
+  (if (quoted-form? sexpr)
+    (second sexpr)
+    sexpr))
+
+(defn- extract-bind-ns-var
+  [spec-data]
+  (let [pairs (partition 2 (rest spec-data))
+        bind-ns-val (some (fn [[k v]] (when (= :bind-ns k) v)) pairs)
+        as-val (some (fn [[k v]] (when (= :as k) v)) pairs)]
+    (when bind-ns-val
+      (or as-val
+          (when-let [first-sym (first spec-data)]
+            (symbol (last (clojure.string/split (str first-sym) #"\."))))))))
+
+(defn- extract-refer-symbols
+  [spec-data]
+  (let [pairs (partition 2 (rest spec-data))
+        refer-val (some (fn [[k v]] (when (= :refer k) v)) pairs)]
+    (when (and refer-val (vector? refer-val))
+      refer-val)))
+
+(defn- filter-spec-data
+  [spec-data]
+  (loop [result []
+         remaining (rest spec-data)]
+    (if (empty? remaining)
+      (vec (cons (first spec-data) result))
+      (let [item (first remaining)
+            next-item (second remaining)]
+        (cond
+          (libpython-unary-flags item)
+          (if (boolean? next-item)
+            (recur result (drop 2 remaining))
+            (recur result (rest remaining)))
+
+          (libpython-binary-flags item)
+          (recur result (drop 2 remaining))
+
+          :else
+          (recur (conj result item) (rest remaining)))))))
+
+(defn- process-spec-data
+  [sexpr]
+  (let [unquoted (unquote-sexpr sexpr)]
+    (cond
+      (vector? unquoted)
+      {:spec-data (filter-spec-data unquoted)
+       :bind-ns-var (extract-bind-ns-var unquoted)
+       :refer-symbols (extract-refer-symbols unquoted)}
+
+      (symbol? unquoted)
+      {:spec-data unquoted
+       :bind-ns-var nil
+       :refer-symbols nil}
+
+      :else
+      {:spec-data unquoted
+       :bind-ns-var nil
+       :refer-symbols nil})))
+
+(defn- make-require-form
+  [specs]
+  (list* 'require
+         (map (fn [spec] (list 'quote spec)) specs)))
+
+(defn- make-def-form
+  [var-name]
+  (list 'def var-name nil))
+
+(defn require-python
+  [{:keys [node]}]
+  (let [form (get-sexpr node)
+        args (rest form)
+        processed (map process-spec-data args)
+        spec-data-list (map :spec-data processed)
+        bind-ns-vars (filter some? (map :bind-ns-var processed))
+        refer-symbols (mapcat :refer-symbols processed)
+        require-form (make-require-form spec-data-list)
+        def-forms (map make-def-form (concat bind-ns-vars refer-symbols))
+        result-form (if (seq def-forms)
+                      (list* 'do require-form def-forms)
+                      require-form)
+        result-node (api/coerce result-form)]
+    {:node (with-meta result-node (meta node))}))