pyanime4k 3.0.0__cp38-cp38-win_amd64.whl

pyanime4k/__init__.py

@@ -0,0 +1,4 @@
+from .image_io import *
+from .info import *
+from .processor import *
+from .upscale import *

pyanime4k/image_io.py

@@ -0,0 +1,9 @@
+import numpy
+
+from . import pyac
+
+def imread(filename: str) -> numpy.ndarray:
+    return pyac.core.imread(filename, pyac.core.IMREAD_UNCHANGED)
+
+def imwrite(filename: str, image: numpy.ndarray) -> bool:
+    return pyac.core.imwrite(filename, image)

pyanime4k/info.py

@@ -0,0 +1,13 @@
+from . import pyac
+
+def print_model_list():
+    for name, description in zip(pyac.specs.ModelNameList, pyac.specs.ModelDescriptionList):
+        print(f"{name}\t\t{description}")
+
+def print_processor_list():
+    for name, description in zip(pyac.specs.ProcessorNameList, pyac.specs.ProcessorDescriptionList):
+        print(f"{name}\t\t{description}")
+
+def print_device_list():
+    for info in pyac.core.Processor.InfoList:
+        print(info, end="")

pyanime4k/processor.py

@@ -0,0 +1,27 @@
+import numpy
+
+from . import pyac
+
+class Processor:
+    def __init__(self, processor_name: str = "cpu", device_id:int = 0, model_name: str = "acnet-hdn0"):
+        self.processor_name = processor_name.lower()
+        if self.processor_name == "opencl" :
+            processor_type = pyac.core.Processor.OpenCL
+        if self.processor_name == "cuda":
+            processor_type = pyac.core.Processor.CUDA
+        else:
+            self.processor_name = "cpu"
+            processor_type = pyac.core.Processor.CPU
+
+        self.processor = pyac.core.Processor(processor_type = processor_type, device = device_id, model = model_name)
+        if not self.processor.ok():
+            raise RuntimeError(self.processor.error())
+    
+    def __call__(self, src: numpy.ndarray, factor: float = 2.0) -> numpy.ndarray:
+        dst = self.processor.process(src = src, factor = factor)
+        if not self.processor.ok():
+            raise RuntimeError(self.processor.error())
+        return dst
+
+    def __str__(self):
+        return f"{self.processor_nam}: {self.processor.name()}"

pyanime4k/pyac/__init__.py

@@ -0,0 +1 @@
+from .pyac import *

pyanime4k/upscale.py

@@ -0,0 +1,29 @@
+from itertools import zip_longest, islice
+from pathlib import Path
+
+from .image_io import imread, imwrite
+from .processor import Processor
+
+def upscale_images(
+    inputs: list,
+    outputs: list = [],
+    output_suffix: str = "_output",
+    factor: float = 2.0,
+    processor_name: str = "cpu",
+    device_id:int = 0,
+    model_name: str = "acnet-hdn0"
+):
+    if isinstance(inputs, str):
+        inputs = [inputs]
+
+    processor = Processor(processor_name, device_id, model_name)
+
+    for input, output in islice(zip_longest(inputs, outputs, fillvalue=None), len(inputs)):
+        if output is None:
+            input_path = Path(input)
+            output = str(input_path.with_stem(input_path.stem + output_suffix))
+
+        src = imread(input)
+        dst = processor(src, factor)
+        if not imwrite(output, dst):
+            raise IOError(f"Failed to save image to {output}")

pyanime4k-3.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 TianZer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyanime4k-3.0.0.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.1
+Name: pyanime4k
+Version: 3.0.0
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# PyAnime4K
+
+PyAnime4K is a high performance anime image upscaler based on [Anime4KCPP](https://github.com/TianZerL/Anime4KCPP).
+
+# Install
+PyAnime4K can be installed easily through pip.
+```shell
+pip install pyanime4k
+```
+
+You can also build the wheel by yourself.
+```shell
+# sudo apt install ocl-icd-opencl-dev cmake build-essential
+get clone https://github.com/TianZerL/pyanime4k.git
+cd pyanime4k
+python setup.py bdist_wheel  
+```
+
+# Usages
+## Printing Info
+```python
+import pyanime4k
+
+# Print supported model
+pyanime4k.print_model_list()
+
+# Print supported processor
+pyanime4k.print_processor_list()
+
+# Print supported devices for image processing
+pyanime4k.print_device_list()
+```
+## Upscaling Images
+```python
+import pyanime4k
+
+# with OpenCL acceleration, if possible
+processor_name = "opencl"
+
+# upscale a single image
+pyanime4k.upscale_images("image1.png", processor_name = processor_name)
+
+# upscale a list of images
+pyanime4k.upscale_images(["image1.png", "image2.png"], processor_name = processor_name)
+```
+## Manual Upscaling
+```python
+import pyanime4k
+
+# Create a processor
+processor = pyanime4k.Processor(
+    processor_name="cpu",
+    device_id=0,
+    model_name="acnet-hdn0"
+)
+# Print processor info
+print(processor)
+# Read an image
+src = pyanime4k.imread("image1.png")
+# Process it
+dst = processor(src=src, factor=2.0)
+# Write to disk
+pyanime4k.imwrite("image1_outout.png", dst)
+```
+## OpenCV
+``` Python
+import cv2, pyanime4k
+
+img = cv2.imread("image.png")
+
+processor = pyanime4k.Processor(
+    processor_name="cpu",
+    device_id=0,
+    model_name="acnet-hdn0"
+)
+
+# opencv load image as BGR, but we need an RGB image
+src = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
+dst = processor(src)
+
+img = cv2.cvtColor(dst, cv2.COLOR_RGB2BGR)
+
+cv2.imshow("pyanime4k", img)
+cv2.waitKey()
+```
+## Pillow
+```python
+from PIL import Image
+import numpy, pyanime4k
+
+img = Image.open("D:/temp/p1.png")
+
+processor = pyanime4k.Processor(
+    processor_name="cpu",
+    device_id=0,
+    model_name="acnet-hdn0"
+)
+
+# We need a numpy array
+src = numpy.asarray(img)
+dst = processor(src)
+img = Image.fromarray(dst)
+
+img.show()
+```

pyanime4k-3.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+pyanime4k/__init__.py,sha256=a0P3gyxYbvjRm8m3suGuv_VK4wXoMeaqIEcOp7jI3jg,96
+pyanime4k/image_io.py,sha256=SRADSi197gcWcMPPljh5-tV-qBXcl-drRmWua2ff1Vg,258
+pyanime4k/info.py,sha256=nkNPTJM99bnWY-pG7UsfD2Ce_efB3FN-HFxfC6-MM9k,464
+pyanime4k/processor.py,sha256=xLASpJaRnCGA96F0N4uxSmDqLn3CDkqJzUc72tLCMPc,1099
+pyanime4k/upscale.py,sha256=c8tYsFHaH-ujdCXc0WRLdeZZT643TzCIqYvV7b_XFnc,913
+pyanime4k/pyac/__init__.py,sha256=zPAeBR1mdz2q_I3Ruk5uaIptB7DjT8P9G20oGEKFJ1c,21
+pyanime4k/pyac/pyac.cp38-win_amd64.pyd,sha256=CawgQb_eYa2k6GkYHjHaiWWoVqw-jrwCBpkbHok7yqA,1595392
+pyanime4k-3.0.0.dist-info/LICENSE,sha256=Y1LqP77JBqrXWO4jJ_2bg6N-hHoU_JGgxQnYqxw1f3U,1085
+pyanime4k-3.0.0.dist-info/METADATA,sha256=9M6u16ID4LGZ2ZFyfZ2VSERss3tfEbgBUX8qD1ZzQJk,2380
+pyanime4k-3.0.0.dist-info/WHEEL,sha256=fE_NFyeaM8vcDHEZHjUwuIwCfAX272sKvaz9mWJ3HC4,94
+pyanime4k-3.0.0.dist-info/top_level.txt,sha256=fPnXpjwQ6pB0I-OoT611DbqcY50uFsaMw4BdYnAmVq0,10
+pyanime4k-3.0.0.dist-info/RECORD,,

pyanime4k-3.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: skbuild 0.18.1
+Root-Is-Purelib: false
+Tag: cp38-cp38-win_amd64
+

pyanime4k-3.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyanime4k