Ajax + jsRender

<!DOCTYPE html>
<html lang="ja">
<head>
  <meta charset="UTF-8">
  <title>jsRender</title>
  <script src="//code.jquery.com/jquery-1.12.4.js"></script>
  <script src="//www.jsviews.com/download/jsrender.js"></script>
  <script src="main.js"></script>
</head>
<body>
  <div id="container"></div>
</body>
</html>

<div>
  <h2>{{:title}}</h2>
  <p>{{:body}}</p>
</div>

$(function(){
  $.ajax({
    url:"template.html",
    type:"GET",
    dataType: 'html'
  }).done(function(data) {
    var tmpl = $.templates(data);
    var data = { title: "Hello World", body: "This is a simple demo." };
    var html = tmpl.render(data);
    $("#container").html(html);
  });
});

jsRender

<!DOCTYPE html>
<html lang="ja">
<head>
  <meta charset="UTF-8">
  <title>jsRender</title>
  <script src="//code.jquery.com/jquery-1.12.4.js"></script>
  <script src="//www.jsviews.com/download/jsrender.js"></script>
  <script id="template" type="text/x-jsrender">
    <div>
        <h2>{{:title}}</h2>
        <p>{{:body}}</p>
    </div>
  </script>
  <script src="main.js"></script>
</head>
<body>
  <div id="container"></div>
</body>
</html>

$(function(){
  var tmpl = $.templates("#template");
  var data = { title: "Hello World", body: "This is a simple demo." };
  var html = tmpl.render(data);
  $("#container").html(html);
});

TypeScriptをvscodeでデバッグする

・tsconfig.json生成
tsc --init でtsconfig.jsonを生成。

・tsconfig.json編集
"sourceMap": true
"rootDir": "./src"
"outDir": "./dist"

・launch.json編集
"preLaunchTask": "tsc: build - tsconfig.json" を追加
 vscodeのタスクシステムで実行される。
 tsc: buildはデフォルトで追加されている。タスクを追加する場合、tasks.jsonで定義。

tipプラグイン解析

tip.js 651行目
ナビボタン書き出しで、tip_listのページボタンを表示してる。
この処理はnavi関数内にあり、displayTiplist関数から呼ばれる。
displayTiplist関数は「TIPリスト」ボタンが押された時に呼ばれる(init.ks内)。

tip.html 17行目
class="tip_head"
 →tip_head: backgroundで青のグラデーション

pytorch lightning 1.9.4

import torch
from torch import nn
from torch.nn import functional as F
from torch.utils.data import DataLoader, random_split
from pytorch_lightning import LightningModule, Trainer
from pytorch_lightning.loggers import CSVLogger
from pytorch_lightning.callbacks.early_stopping import EarlyStopping
from torchvision import transforms
from torchvision.datasets import MNIST
from torchmetrics import Accuracy


class LitMNIST(LightningModule):

def __init__(self):
super().__init__()

input_size = 28 * 28
hidden_size = 256
num_classes = 10
self.batch_size = 256
self.learning_rate = 2e-4
self.num_workers = 0
self.data_dir = 'data'

self.transform = transforms.Compose(
[
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,)),
]
)

self.model = nn.Sequential(
nn.Flatten(),
nn.Linear(input_size, hidden_size),
nn.ReLU(),
nn.Dropout(0.1),
nn.Linear(hidden_size, hidden_size),
nn.ReLU(),
nn.Dropout(0.1),
nn.Linear(hidden_size, num_classes),
)

self.val_accuracy = Accuracy(task="multiclass", num_classes=num_classes)
self.test_accuracy = Accuracy(task="multiclass", num_classes=num_classes)

def forward(self, x):
output = self.model(x)
return output

def training_step(self, batch, batch_idx):
x, y = batch
output = self(x)
loss = F.cross_entropy(output, y)
self.log("train_loss", loss, on_step=False, on_epoch=True)
return loss

def validation_step(self, batch, batch_idx):
x, y = batch
output = self(x)
loss = F.cross_entropy(output, y)
preds = torch.argmax(output, dim=1)
self.val_accuracy.update(preds, y)

self.log("val_loss", loss, on_step=False, on_epoch=True)
self.log("val_acc", self.val_accuracy, on_step=False, on_epoch=True)

def test_step(self, batch, batch_idx):
x, y = batch
output = self(x)
loss = F.cross_entropy(output, y)
preds = torch.argmax(output, dim=1)
self.test_accuracy.update(preds, y)

self.log("test_loss", loss, on_step=False, on_epoch=True)
self.log("test_acc", self.test_accuracy, on_step=False, on_epoch=True)

def configure_optimizers(self):
optimizer = torch.optim.Adam(self.parameters(), lr=self.learning_rate)
return optimizer

def setup(self, stage=None):
# Assign train/val datasets for use in dataloaders
if stage == "fit" or stage is None:
mnist = MNIST(self.data_dir, train=True, download=True, transform=self.transform)
self.mnist_train, self.mnist_val = random_split(mnist, [55000, 5000])

# Assign test dataset for use in dataloader(s)
if stage == "test" or stage is None:
self.mnist_test = MNIST(self.data_dir, train=False, download=True, transform=self.transform)

def train_dataloader(self):
return DataLoader(self.mnist_train, batch_size=self.batch_size, num_workers=self.num_workers)

def val_dataloader(self):
return DataLoader(self.mnist_val, batch_size=self.batch_size, num_workers=self.num_workers)

def test_dataloader(self):
return DataLoader(self.mnist_test, batch_size=self.batch_size, num_workers=self.num_workers)


def main():
model = LitMNIST()
early_stop_callback = EarlyStopping(monitor="val_loss", patience=10, mode="min")
trainer = Trainer(
accelerator="auto",
devices=1,
max_epochs=100,
logger=CSVLogger(save_dir="logs/"),
callbacks=[early_stop_callback]
)
trainer.fit(model)
trainer.test(model)


if __name__ == '__main__':
main()

krita plugin

・server.py

import uvicorn
from fastapi import FastAPI
from pydantic import BaseModel
import cv2


app = FastAPI()


class Request(BaseModel):
input_img_path: str
output_img_path: str


@app.post("/blur")
async def f_blur(req: Request):
input_img = cv2.imread(req.input_img_path)
output_img = cv2.blur(input_img, (5, 5))
cv2.imwrite(req.output_img_path, output_img)


def start():
config = uvicorn.Config("server:app", host="127.0.0.1", port=8000, log_level="info")
server = uvicorn.Server(config=config)
server.run()


if __name__ == '__main__':
start()


blur_plugin.py

from krita import DockWidget
from PyQt5.QtWidgets import *
from .blur_action import BlurAction


DOCKER_TITLE = 'Blur Docker'


class BlurDock(DockWidget):

def __init__(self):
super().__init__()
self.setWindowTitle(DOCKER_TITLE)

self.action = BlurAction()

self.button = QPushButton('Blur')
self.button.clicked.connect(self.action.blur)

self.layout = QVBoxLayout()
self.layout.addWidget(self.button)
widget = QWidget(self)
widget.setLayout(self.layout)
self.setWidget(widget)

# notifies when views are added or removed
# 'pass' means do not do anything
def canvasChanged(self, canvas):
pass


blur_action.py

import os
import json
import urllib.request
import tempfile
from PyQt5.QtGui import *
from PyQt5.QtCore import *


class BlurAction:
def __init__(self):
self.url = 'http://127.0.0.1:8000/blur'
self.input_img_name = 'input.png'
self.output_img_name = 'output.png'

def blur(self):
with tempfile.TemporaryDirectory() as tempfolder:
post_data = self.create_input_data(tempfolder)
req = urllib.request.Request(
self.url,
headers={'Content-Type': 'application/json'},
data=json.dumps(post_data).encode('utf-8')
)
with urllib.request.urlopen(req):
self.apply_result(tempfolder)

def create_input_data(self, tempfolder):

doc = Krita.instance().activeDocument()
pixel_bytes = doc.activeNode().pixelData(0, 0, doc.width(), doc.height())
img = QImage(pixel_bytes, doc.width(), doc.height(), QImage.Format_RGBA8888).rgbSwapped()
input_img_path = os.path.join(tempfolder, self.input_img_name)
output_img_path = os.path.join(tempfolder, self.output_img_name)
img.save(input_img_path, "PNG")

post_data = {
'input_img_path': input_img_path,
'output_img_path': output_img_path
}
return post_data

def apply_result(self, tempfolder):
img = QImage()
img.load(os.path.join(tempfolder, self.output_img_name))
ptr = img.bits()
ptr.setsize(img.byteCount())
byte_array = QByteArray(ptr.asstring())
doc = Krita.instance().activeDocument()
doc.activeNode().setPixelData(byte_array, 0, 0, img.width(), img.height())
doc.refreshProjection()

 

uvicornとFastAPIによるサーバー構築 その2

server.py

import uvicorn
from fastapi import FastAPI
from pydantic import BaseModel


app = FastAPI()


class Request(BaseModel):
message: str


@app.post("/hoge_post")
async def hoge_func(req: Request):
print(req.message)
return {'output': req.message}


def start():
config = uvicorn.Config("server:app", host="127.0.0.1", port=8000, log_level="info")
server = uvicorn.Server(config=config)
server.run()


if __name__ == '__main__':
start()


client.py

import json
import urllib.request


def make_data():
data = {
'message': 'hello'
}
return data


def client():
req = urllib.request.Request(
'http://127.0.0.1:8000/hoge_post',
headers={'Content-Type': 'application/json'},
data=json.dumps(make_data()).encode('utf-8')
)
with urllib.request.urlopen(req) as res:
print(json.load(res))


if __name__ == '__main__':
client()