ct 0.10.8.114__py3-none-any.whl → 0.10.8.116__py3-none-any.whl

cantools/util/ai/vox.py

@@ -0,0 +1,84 @@
+import random
+from ..system import cmd
+
+class Kvox(object):
+	def __init__(self, log=print):
+		self.logger = log
+		self.kpipes = {}
+
+	def log(self, *msg):
+		self.logger("Kvox", *msg)
+
+	def getpipe(self, lang_code):
+		from kokoro import KPipeline
+		if lang_code not in self.kpipes:
+			self.kpipes[lang_code] = KPipeline(lang_code=lang_code)
+		return self.kpipes[lang_code]
+
+	def vi(self, t, v):
+		t = round(t)
+		self.log("viseme with time", t, "and value", v)
+		return { "time": t, "value": v }
+
+	def token2visemes(self, token, visemes):
+		self.log("token2visemes", token.text, token.phonemes, token.start_ts, token.end_ts)
+		phos = token.text # phonemes are full of unicode....
+		step = 1000 * (token.end_ts - token.start_ts) / len(phos)
+		t = 1000 * token.start_ts
+		for pho in phos:
+			visemes.append(self.vi(t, pho))
+			t += step
+		return t
+
+	def tokens2visemes(self, tokens):
+		self.log("tokens2visemes")
+		t = 0
+		visemes = []
+		for token in tokens:
+			t = self.token2visemes(token, visemes)
+		visemes.append(self.vi(t, "sil"))
+		return visemes
+
+	def __call__(self, text, voice="af_heart", speed=1, lang_code='a', filename="tts"):
+		import json, soundfile
+		pipeline = self.getpipe(lang_code)
+		nothing, tokens = pipeline.g2p(text)
+		for result in pipeline.generate_from_tokens(tokens=tokens, voice=voice, speed=float(speed)):
+			self.log(result.phonemes)
+			vz = self.tokens2visemes(result.tokens)
+			vname = "%s.json"%(filename,)
+			aname = "%s.mp3"%(filename,)
+			self.log("writing", vname)
+			with open(vname, "w") as f:
+				f.write("%s\n"%("\n".join([json.dumps(v) for v in vz]),))
+			self.log("writing", aname)
+			soundfile.write(aname, result.audio, 24000)
+
+VAGENT = None
+kvox = Kvox()
+kvoices = [
+	"af_heart", "af_bella", "af_nicole", "af_aoede", "af_kore", "af_sarah", "af_nova",
+	"af_sky", "af_alloy", "af_jessica", "af_river", "am_michael", "am_fenrir", "am_puck",
+	"am_echo", "am_eric", "am_liam", "am_onyx", "am_santa", "am_adam", "bf_emma",
+	"bf_isabella", "bf_alice", "bf_lily", "bm_george", "bm_fable", "bm_lewis", "bm_daniel"
+]
+
+def vagent():
+	global VAGENT
+	if not VAGENT:
+		from venvr import getagent
+		VAGENT = getagent("kovo", ["kokoro", "soundfile"])
+		VAGENT.register(Kvox)
+	return VAGENT
+
+def vox(text, voice="af_heart", speed=1, lang_code='a', filename="tts", say=False):
+	if voice == "random":
+		voice = random.choice(kvoices)
+	try:
+		import kokoro
+		print("found kokoro")
+		kvox(text, voice, speed, lang_code, filename)
+	except:
+		print("no kokoro - using venvr")
+		vagent().run("Kvox", text, voice, speed, lang_code, filename)
+	say and cmd("mplayer %s.mp3"%(filename,))

cantools/util/apper/__init__.py

@@ -0,0 +1 @@
+from .ander import android

cantools/util/apper/ander.py

@@ -0,0 +1,101 @@
+import os
+from fyg.util import log, ask, confirm, selnum
+from cantools.util import cmd, output, mkdir, cp
+from cantools.util.system import envget, envset
+from cantools.util.admin import _which, javaver
+from .data import TEMPLATES
+
+class Android(object):
+	def __init__(self, url, name=None, package=None, auto=False):
+		self.setVars(url, name, package, auto)
+		self.setMode()
+		self.dirs()
+		self.files()
+		self.icons()
+		os.chdir(self.name)
+		self.apk()
+		self.install()
+		log("goodbye")
+
+	def setVars(self, url, name=None, package=None, auto=False):
+		if "://" not in url:
+			url = "https://%s"%(url,)
+		parts = url.split("://").pop().split("/").pop(0).split(".")
+		self.url = url
+		self.auto = auto
+		self.name = name or self.ask("name", parts[0])
+		parts.reverse()
+		self.package = package or self.ask("package name", ".".join(parts))
+		self.dir = self.package.replace(".", "/")
+		self.tmps = TEMPLATES["android"]
+
+	def ask(self, question, default=None):
+		if default and self.auto:
+			log("question '%s' -> choosing '%s'"%(question, default), important=True)
+			return default
+		return ask(question, default)
+
+	def conf(self, condition, default=False):
+		if self.auto:
+			log("confirmation '%s' -> deciding '%s'"%(condition, default), important=True)
+			return default
+		return confirm(condition, default)
+
+	def setMode(self, mode="debug"):
+		self.mode = mode
+		self.debug = mode == "debug"
+
+	def dirs(self):
+		if not self.conf("assemble directory hierarchy", True): return
+		mkdir("%s/src/main/java/%s"%(self.name, self.dir), True)
+		mkdir("%s/src/main/res"%(self.name,))
+
+	def files(self):
+		if not self.conf("create project files", True): return
+		self.jv = javaver()
+		cp(self.tmps["manifest"]%(self.name, self.package, self.name),
+			"%s/src/main/AndroidManifest.xml"%(self.name))
+		cp(self.tmps["activity"]%(self.package, self.url),
+			"%s/src/main/java/%s/MainActivity.java"%(self.name, self.dir))
+		cp(self.tmps["gradle"]%(self.package, self.jv, self.jv),
+			"%s/build.gradle"%(self.name,))
+		cp(self.tmps["properties"], "%s/gradle.properties"%(self.name,))
+
+	def icons(self):
+		if not self.conf("generate icons", True): return
+		ipath = self.ask("image path", "icon.png")
+		for k, v in self.tmps["isizes"].items():
+			wpath = "%s/src/main/res/drawable-%s"%(self.name, k)
+			mkdir(wpath)
+			cmd(self.tmps["icons"]%(ipath, v, wpath))
+
+	def chenv(self):
+		for name, cfg in self.tmps["env"].items():
+			if not envget(name):
+				log("%s not set!"%(name,))
+				envset(name, self.ask("%s location"%(name,),
+					output("locate %s"%(cfg["locater"].replace("_JV_",
+						self.jv),)).split(cfg["splitter"]).pop(0)))
+
+	def apk(self):
+		if not self.conf("build apk", True): return
+		self.chenv()
+		self.setMode(selnum(["debug", "release"]))
+		gcmd = self.debug and "assembleDebug" or "assemble"
+		if self.conf("add stacktrace flag"):
+			gcmd = "%s --stacktrace"%(gcmd,)
+		if self.conf("specify trustStore cacerts", True):
+			tsca = selnum(output("locate cacerts | grep java").split("\n"))
+			tspw = self.ask("trustStore password", "changeit")
+			gcmd = self.tmps["tstore"]%(gcmd, tsca, tspw)
+		cmd("gradle %s"%(gcmd,))
+
+	def install(self):
+		if not self.conf("install on device", True): return
+		aname = self.debug and "%s-debug"%(self.name,) or self.name
+		cmd("adb install build/outputs/apk/%s/%s.apk"%(self.mode, aname))
+
+def android(url=None, auto=False):
+	if not _which("java", "gradle", "adb", "convert"):
+		return log("build aborted!")
+	Android(url or ask("url", "http://ct.mkult.co"), auto=auto)

cantools/util/apper/data.py

@@ -0,0 +1,167 @@
+# reference:
+# - https://github.com/raelmax/android-webview
+# - https://czak.pl/posts/minimal-android-project
+
+AMAN = """<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    android:versionCode="1"
+    android:versionName="1.0" >
+
+    <uses-sdk />
+
+    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.CAMERA" />
+
+    <application
+        android:allowBackup="true"
+        android:icon="@drawable/ic_launcher"
+        android:label="%s"
+        android:theme="@android:style/Theme.NoTitleBar" >
+        <activity
+            android:name="%s.MainActivity"
+            android:configChanges="orientation|screenSize"
+            android:label="%s"
+            android:exported="true" >
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>
+"""
+
+AMAC = """package %s;
+import android.Manifest;
+import android.app.Activity;
+import android.os.Bundle;
+import android.view.KeyEvent;
+import android.view.Window;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+import android.webkit.WebChromeClient;
+import android.webkit.PermissionRequest;
+import android.content.pm.PackageManager;
+import androidx.core.content.ContextCompat;
+
+public class MainActivity extends Activity {
+    private WebView mWebView;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        MainActivity thaz = this;
+        getWindow().requestFeature(Window.FEATURE_NO_TITLE);
+        mWebView = new WebView(this);
+        mWebView.getSettings().setMediaPlaybackRequiresUserGesture(false);
+        mWebView.getSettings().setJavaScriptEnabled(true);
+        mWebView.getSettings().setDomStorageEnabled(true);
+        mWebView.getSettings().setUseWideViewPort(true);
+        mWebView.loadUrl("%s");
+        mWebView.setWebViewClient(new WebViewClient() {
+            @Override
+            public boolean shouldOverrideUrlLoading(WebView view, String url) {
+                view.loadUrl(url);
+                return true;
+            }
+        });
+        mWebView.setWebChromeClient(new WebChromeClient(){
+            // Need to accept permissions to use the camera
+            @Override
+            public void onPermissionRequest(final PermissionRequest request) {
+                // grants permission for app. video not showing
+                if (ContextCompat.checkSelfPermission(thaz, Manifest.permission.CAMERA)
+                    != PackageManager.PERMISSION_GRANTED
+                ) {
+                    requestPermissions(new String[]{Manifest.permission.CAMERA}, 1010);
+                }
+
+                if (ContextCompat.checkSelfPermission(thaz, Manifest.permission.RECORD_AUDIO)
+                    != PackageManager.PERMISSION_GRANTED
+                ) {
+                    requestPermissions(new String[]{Manifest.permission.RECORD_AUDIO}, 1010);
+                }
+
+                request.grant(request.getResources()); // is this right?
+            }
+        });
+        this.setContentView(mWebView);
+    }
+
+    @Override
+    public boolean onKeyDown(final int keyCode, final KeyEvent event) {
+        if ((keyCode == KeyEvent.KEYCODE_BACK) && mWebView.canGoBack()) {
+            mWebView.goBack();
+            return true;
+        }
+        return super.onKeyDown(keyCode, event);
+    }
+}"""
+
+ABG = """buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.5.2'
+    }
+}
+
+repositories {
+    google()
+}
+
+apply plugin: 'com.android.application'
+
+dependencies {
+    implementation 'androidx.appcompat:appcompat:1.1.0'
+}
+
+android {
+    namespace = "%s"
+
+    compileSdkVersion 34
+
+    defaultConfig {
+        targetSdk = 34
+        minSdkVersion = 14
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_%s
+        targetCompatibility JavaVersion.VERSION_%s
+    }
+}"""
+
+AGP = """android.useAndroidX=true
+android.enableJetifier=true"""
+
+TEMPLATES = {
+    "android": {
+        "manifest": AMAN,
+        "activity": AMAC,
+        "gradle": ABG,
+        "properties": AGP,
+        "icons": "convert -background none %s -resize %s %s/ic_launcher.png",
+        "tstore": "%s -Djavax.net.ssl.trustStore=%s -Djavax.net.ssl.trustStorePassword=%s",
+        "isizes": {
+            'ldpi': '36x36',
+            'mdpi': '48x48',
+            'hdpi': '72x72',
+            'xhdpi': '96x96'
+        },
+        "env": {
+            "JAVA_HOME": {
+                "locater": "cacerts|grep jvm/java-_JV_-",
+                "splitter": "/lib/security"
+            },
+            "ANDROID_HOME": {
+                "locater": "/lib/android-sdk",
+                "splitter": "\n"
+            }
+        }
+    }
+}

cantools/util/system.py

@@ -1,9 +1,5 @@
-import os, sys, subprocess, platform
-try:
-	from commands import getoutput   # py2
-except:
-	from subprocess import getoutput # py3
-from fyg.util import log, read, write, rm
+import os, sys
+from fyg.util import log, read, write, rm, sudoed, cmd, output
 
 def cp(content, fname): # more write than copy, buuuut...
 	log("writing %s"%(fname,), 2)
@@ -40,23 +36,6 @@ def mkdir(pname, recursive=False):
 def sed(fname, flag, replacement, target=None):
 	write(read(fname).replace(flag, replacement), target or fname)
 
-def sudoed(cline, sudo=False):
-	if sudo and platform.system() != "Windows" and os.geteuid(): # !root
-		cline = "sudo %s"%(cline,)
-	return cline
-
-def cmd(cline, sudo=False, silent=False):
-	cline = sudoed(cline, sudo)
-	silent or log('issuing command: "%s"'%(cline,), 2)
-	subprocess.call(cline, shell=True)
-
-def output(cline, sudo=False, silent=False, loud=False):
-	cline = sudoed(cline, sudo)
-	silent or log('getting output for: "%s"'%(cline,), 2)
-	output = getoutput(cline)
-	loud and log(output)
-	return output
-
 def envget(name):
 	return output("echo $%s"%(name,))
 

cantools/web/__init__.py

@@ -1,9 +1,13 @@
-from .util import config
+from cantools import config
 
 if config.web.server == "gae":
 	from .gae_server import *
 elif config.web.server == "dez":
-	from cantools.web.dez_server import *
+	from .bw import *
+	from babyweb import *
+	from babyweb import mail
+	from babyweb.sms import send_sms
+	from babyweb.mail import send_mail, email_admins, email_reportees, mailer, reader, check_inbox, scanner, on_mail
 else:
 	from cantools import util
 	util.error("no web server specified")

cantools/web/bw.py

@@ -0,0 +1,70 @@
+import json, gc, os, inspect, threading, psutil
+from babyweb.daemons import WebBase, initWebs, logger_getter
+from babyweb.server import run_dez_webserver
+from babyweb.config import config as babyfyg
+from babyweb.logger import log, syslog
+from ..util import init_rel
+from cantools import config
+
+A_STATIC = {
+    "dynamic": { "/": "_/dynamic", "/css/": "_/css", "/js/CT/": "js/CT", "/logs/": "logs", "/logs": "logs" },
+    "static": { "/": "_/static", "/css/": "_/css", "/js/CT/": "js/CT", "/logs/": "logs", "/logs": "logs" },
+    "production": { "/": "_/production", "/css/": "_/css", "/logs/": "logs", "/logs": "logs" },
+}
+A_CB = { "/admin": "admin", "/_db": "_db" }
+
+def setcfg():
+	syslog("passing configuration to babyweb")
+	for prop in ["cache", "encode", "mempad", "web", "cron", "scrambler"]:
+		babyfyg.update(prop, config[prop])
+	for prop in ["contacts", "reportees"]:
+		babyfyg.admin.update(prop, config.admin[prop])
+	for prop in ["verify", "certfile", "keyfile", "cacerts"]:
+		babyfyg.ssl.update(prop, config.ssl[prop])
+	for prop in ["oflist", "openfiles", "tracemalloc", "allow"]:
+		babyfyg.log.update(prop, config.log[prop])
+	for prop in ["active", "user", "gateway", "minport", "maxport"]:
+		babyfyg.proxy.update(prop, config.proxy[prop])
+	babyfyg.update("memcache", config.memcache.request)
+	bmfg = babyfyg.mail
+	bmfg.update("mailer", config.mailer)
+	bmfg.update("gmailer", config.gmailer)
+	bmfg.update("name", config.mailername)
+	bmfg.update("html", config.mailhtml)
+	bmfg.update("verbose", config.mailoud)
+	bmfg.update("scantick", config.mailscantick)
+
+setcfg()
+
+class Admin(WebBase):
+    def __init__(self, bind_address, port, logger_getter, shield, mempad):
+        self.logger = logger_getter("Admin")
+        acfg = config.admin
+        WebBase.__init__(self, bind_address, port, logger_getter, # share shield/blacklist
+            A_STATIC[config.mode], A_CB, acfg.whitelist, config.web.blacklist, shield, mempad)
+        self.add_cb_rule("/_report", self.report)
+
+    def report(self, req):
+        report = json.dumps({
+            "threads": threading.active_count(),
+            "stack_frames": len(inspect.stack()),
+            "web": self.controller.webs["web"].daemon.counter.report(),
+            "admin": self.daemon.counter.report(),
+            "gc": len(gc.get_objects()),
+            "mem": psutil.Process(os.getpid()).memory_percent()
+        })
+        self.logger.info(report)
+        self.daemon.respond(req, report)
+
+def run_bw():
+	syslog("initializing web server")
+	init_rel()
+	initWebs({
+		"admin": {
+			"daemon": Admin,
+			"config": config.admin
+		}
+	})
+	config.admin.update("pw",
+		config.cache("admin password? ", overwrite=config.newpass))
+	run_dez_webserver()

cantools/web/gae_server.py

@@ -60,9 +60,4 @@ def delmem(key):
 
 def clearmem():
     from google.appengine.api import memcache
-    memcache.flush_all()
-
-set_getmem(getmem)
-set_setmem(setmem)
-set_delmem(delmem)
-set_clearmem(clearmem)
+    memcache.flush_all()