Meet jsmacros 1.2.9

build.gradle

@@ -39,7 +39,7 @@ dependencies {
 	mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
 	modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
 
-	modImplementation name: "jsmacros-1.16.4-1.2.8-dev"
+	modImplementation name: "jsmacros-1.16.4-1.2.9-beta-d39b399-dev"
 
 	//partial fabric api
 	modImplementation "net.fabricmc.fabric-api:fabric-api-base:${project.api_base_version}"
@@ -64,10 +64,11 @@ dependencies {
 
 
     //websocket 
-    implementation "org.java-websocket:Java-WebSocket:1.5.1"
-    implementation group: 'org.slf4j', name: 'slf4j-api', version: '1.7.25'
     implementation "com.neovisionaries:nv-websocket-client:2.10"
-
+
+	implementation "io.noties:prism4j:${prism_version}"
+	include "io.noties:prism4j:${prism_version}"
+
 	//nullable not defined so...
 	implementation 'com.google.code.findbugs:jsr305:3.0.2'
 

gradle.properties

@@ -8,7 +8,7 @@ org.gradle.jvmargs=-Xmx1G
 	loader_version=0.9.0+build.204
 
 # Mod Properties
-	mod_version = 1.0.7
+	mod_version = 1.0.8
 	maven_group = xyz.wagyourtail
 	archives_base_name = jsmacros-jython
 
@@ -19,3 +19,5 @@ org.gradle.jvmargs=-Xmx1G
     lifecycle_events_version=1.0.0+b0993bc102
     key_bind_api_version=1.0.0+e16a977402
     resource_loader_version=0.2.5+059ea86602
+
+	prism_version=2.0.0

src/main/java/xyz/wagyourtail/jsmacros/jython/client/JsMacrosJython.java

@@ -0,0 +1,33 @@
+package xyz.wagyourtail.jsmacros.jython.client;
+
+import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.loader.api.FabricLoader;
+import org.python.util.PythonInterpreter;
+import xyz.wagyourtail.jsmacros.client.JsMacros;
+import xyz.wagyourtail.jsmacros.jython.language.impl.JythonLanguageDescription;
+import xyz.wagyourtail.jsmacros.jython.library.impl.FConsumerJython;
+
+public class JsMacrosJython implements ClientModInitializer {
+    public static boolean hasJEP = false;
+
+    @Override
+    public void onInitializeClient() {
+        hasJEP = FabricLoader.getInstance().isModLoaded("jsmacros-jep");
+        JsMacros.core.addLanguage(new JythonLanguageDescription(hasJEP ? "jython.py" : ".py", JsMacros.core));
+        JsMacros.core.sortLanguages();
+        JsMacros.core.libraryRegistry.addLibrary(FConsumerJython.class);
+
+
+        // pre-init
+        Thread t = new Thread(() -> {
+            try (PythonInterpreter interp = new PythonInterpreter()) {
+                interp.exec("print(\"Jython Loaded.\")");
+            } catch(Exception e) {
+                e.printStackTrace();
+            }
+        });
+
+        t.start();
+    }
+
+}

src/main/java/xyz/wagyourtail/jsmacros/jython/language/impl/JythonLanguageDescription.java

@@ -0,0 +1,51 @@
+package xyz.wagyourtail.jsmacros.jython.language.impl;
+
+import org.python.util.PythonInterpreter;
+import xyz.wagyourtail.jsmacros.core.Core;
+import xyz.wagyourtail.jsmacros.core.config.ScriptTrigger;
+import xyz.wagyourtail.jsmacros.core.event.BaseEvent;
+import xyz.wagyourtail.jsmacros.core.language.BaseLanguage;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.util.Map;
+
+public class JythonLanguageDescription extends BaseLanguage {
+
+    public JythonLanguageDescription(String extension, Core runner) {
+        super(extension, runner);
+    }
+
+    protected void execContext(Executor exec) throws Exception {
+        try (PythonInterpreter interp = new PythonInterpreter()) {
+            retrieveLibs(interp).forEach(interp::set);
+
+            exec.accept(interp);
+        }
+    }
+
+    @Override
+    public void exec(ScriptTrigger scriptTrigger, File file, BaseEvent baseEvent) throws Exception {
+        execContext((interp) -> {
+            interp.set("event", baseEvent);
+            interp.set("file", file);
+
+            interp.exec("import os\nos.chdir('"
+                + file.getParentFile().getCanonicalPath().replaceAll("\\\\", "/") + "')");
+            interp.execfile(file.getCanonicalPath());
+        });
+    }
+
+    @Override
+    public void exec(String script, Map<String, Object> globals, Path path) throws Exception {
+        execContext((interp) -> {
+            globals.forEach(interp::set);
+
+            interp.exec(script);
+        });
+    }
+
+    protected interface Executor {
+        void accept(PythonInterpreter interpreter) throws Exception;
+    }
+}

src/main/java/xyz/wagyourtail/jsmacros/jython/library/impl/FConsumerJython.java

@@ -0,0 +1,152 @@
+package xyz.wagyourtail.jsmacros.jython.library.impl;
+
+import org.python.core.PyFunction;
+import org.python.core.PyObject;
+import xyz.wagyourtail.jsmacros.core.MethodWrapper;
+import xyz.wagyourtail.jsmacros.core.language.BaseLanguage;
+import xyz.wagyourtail.jsmacros.core.library.IFConsumer;
+import xyz.wagyourtail.jsmacros.core.library.Library;
+import xyz.wagyourtail.jsmacros.core.library.PerExecLanguageLibrary;
+import xyz.wagyourtail.jsmacros.jython.language.impl.JythonLanguageDescription;
+
+@Library(value = "consumer", languages = JythonLanguageDescription.class)
+public class FConsumerJython extends PerExecLanguageLibrary<IFConsumer> implements IFConsumer<PyFunction, PyFunction, PyFunction> {
+
+    public FConsumerJython(Class<? extends BaseLanguage> language, Object context, Thread thread) {
+        super(language, context, thread);
+    }
+
+    @Override
+    public <A, B, R> MethodWrapper<A, B, R> toConsumer(PyFunction pyFunction) {
+        return autoWrap(pyFunction);
+    }
+
+    @Override
+    public <A, B, R> MethodWrapper<A, B, R> toBiConsumer(PyFunction pyFunction) {
+        return autoWrap(pyFunction);
+    }
+
+    @Override
+    public <A, B, R> MethodWrapper<A, B, R> toAsyncConsumer(PyFunction pyFunction) {
+        return autoWrapAsync(pyFunction);
+    }
+
+    @Override
+    public <A, B, R> MethodWrapper<A, B, R> toAsyncBiConsumer(PyFunction pyFunction) {
+        return autoWrapAsync(pyFunction);
+    }
+
+    @Override
+    public <A, B, R> MethodWrapper<A, B, R> autoWrap(PyFunction pyFunction) {
+        return new MethodWrapper<A, B, R>() {
+            @Override
+            public void accept(A a) {
+                runInt(a);
+            }
+
+            @Override
+            public void accept(A a, B b) {
+                runInt(a, b);
+            }
+
+            @Override
+            public R apply(A a) {
+                return (R) runInt(a).__tojava__(Object.class);
+            }
+
+            @Override
+            public R apply(A a, B b) {
+                return (R) runInt(a, b).__tojava__(Object.class);
+            }
+
+            @Override
+            public boolean test(A a) {
+                return (boolean) runInt(a).__tojava__(boolean.class);
+            }
+
+            @Override
+            public boolean test(A a, B b) {
+                return (boolean) runInt(a, b).__tojava__(boolean.class);
+            }
+
+            @Override
+            public void run() {
+                runInt();
+            }
+
+            @Override
+            public int compare(A o1, A o2) {
+                return (int) runInt(o1, o2).__tojava__(int.class);
+            }
+
+            @Override
+            public R get() {
+                return (R) runInt().__tojava__(Object.class);
+            }
+
+            private PyObject runInt(Object...args) {
+                return pyFunction._jcall(args);
+            }
+        };
+    }
+
+    @Override
+    public <A, B, R> MethodWrapper<A, B, R> autoWrapAsync(PyFunction pyFunction) {
+        return new MethodWrapper<A, B, R>() {
+            @Override
+            public void accept(A a) {
+                acceptInt(a);
+            }
+
+            @Override
+            public void accept(A a, B b) {
+                acceptInt(a, b);
+            }
+
+            @Override
+            public R apply(A a) {
+                return (R) runInt(a).__tojava__(Object.class);
+            }
+
+            @Override
+            public R apply(A a, B b) {
+                return (R) runInt(a, b).__tojava__(Object.class);
+            }
+
+            @Override
+            public boolean test(A a) {
+                return (boolean) runInt(a).__tojava__(boolean.class);
+            }
+
+            @Override
+            public boolean test(A a, B b) {
+                return (boolean) runInt(a, b).__tojava__(boolean.class);
+            }
+
+            @Override
+            public void run() {
+                acceptInt();
+            }
+
+            @Override
+            public int compare(A o1, A o2) {
+                return (int) runInt(o1, o2).__tojava__(int.class);
+            }
+
+            @Override
+            public R get() {
+                return (R) runInt().__tojava__(Object.class);
+            }
+
+            private PyObject runInt(Object...args) {
+                return pyFunction._jcall(args);
+            }
+
+            private void acceptInt(Object...args) {
+                Thread t = new Thread(() -> pyFunction._jcall(args));
+                t.start();
+            }
+        };
+    }
+
+}