Upload 5 files

captcha_processor.py

@@ -0,0 +1,109 @@
+import cv2
+from numpy import asarray as np_as_array
+from numpy import all as np_all
+
+
+class CaptchaProcessor:
+
+    WHITE_RGB = (255, 255, 255)
+
+    def __init__(self, data: bytes):
+        self.img = cv2.imdecode(
+            np_as_array(bytearray(data), dtype="uint8"),
+            cv2.IMREAD_ANYCOLOR
+        )
+
+    def threshold(self):
+        self.img = cv2.threshold(self.img, 0, 255, cv2.THRESH_OTSU)[1]
+
+    def convert_color_space(self, target_space: int):
+        self.img = cv2.cvtColor(self.img, target_space)
+
+    def get_background_color(self) -> tuple:
+        return tuple(self.img[0, 0])
+
+    def resize(self, x: int, y: int):
+        self.img = cv2.resize(self.img, (x, y))
+
+    def save(self, name: str):
+        cv2.imwrite(name, self.img)
+
+    def get_letters_color(self) -> tuple:
+        colors = []
+        for y in range(self.img.shape[1]):
+            for x in range(self.img.shape[0]):
+                color = tuple(self.img[x, y])
+                if color != self.WHITE_RGB: colors.append(color)
+        return max(set(colors), key=colors.count)
+
+    def replace_color(self, target: tuple, to: tuple):
+        self.img[np_all(self.img == target, axis=-1)] = to
+
+    def replace_colors(self, exception: tuple, to: tuple):
+        self.img[np_all(self.img != exception, axis=-1)] = to
+
+    def increase_contrast(self, alpha: float, beta: float):
+        self.img = cv2.convertScaleAbs(self.img, alpha=alpha, beta=beta)
+
+    def increase_letters_size(self, add_pixels: int):
+        pixels = []
+        for y in range(self.img.shape[1]):
+            for x in range(self.img.shape[0]):
+                if self.img[x, y] == 0: pixels.append((x, y))
+        for y, x in pixels:
+            for i in range(1, add_pixels + 1):
+                self.img[y + i, x] = 0
+                self.img[y - i, x] = 0
+                self.img[y, x + i] = 0
+                self.img[y, x - i] = 0
+                self.img[y + i, x] = 0
+                self.img[y - i, x] = 0
+                self.img[y, x + i] = 0
+                self.img[y, x - i] = 0
+
+    # Отдаление символов друг от друга
+    # Может многократно повысить точность, но я так и не придумал правильную реализацию
+    def distance_letters(self, cf: float):
+        pixels = []
+        for y in range(self.img.shape[1]):
+            for x in range(self.img.shape[0]):
+                if self.img[x, y] == 0: pixels.append((x, y))
+        for y, x in pixels:
+            self.img[y, x] = 255
+            center = self.img.shape[1] / 2
+            z = self.img.shape[1] / x
+            if z >= 2: self.img[y, x - int((900 // x) * cf)] = 0
+            else: self.img[y, x + int((900 // x) * cf)] = 0
+
+    def slice_letters(self):
+        contours, hierarchy = cv2.findContours(self.img, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
+        letter_image_regions = []
+        letters = []
+        for idx, contour in enumerate(contours):
+            if hierarchy[0][idx][3] != 0: continue
+            (x, y, w, h) = cv2.boundingRect(contour)
+            if w / h > 1.5:
+                half_width = int(w / 2)
+                letter_image_regions.append((idx, x, y, half_width, h))
+                letter_image_regions.append((idx, x + half_width, y, half_width, h))
+            else:
+                letter_image_regions.append((idx, x, y, w, h))
+        letter_image_regions = sorted(letter_image_regions, key=lambda z: z[1])
+        for _, x, y, w, h in letter_image_regions:
+            frame = self.img[y:y + h, x:x + w]
+            if frame.shape[1] > 35: continue
+            frame = cv2.resize(frame, (20, 40))
+            frame = cv2.cvtColor(frame,  cv2.COLOR_RGB2BGR)
+            letters.append(frame)
+        return letters
+
+    def show(self):
+        cv2.imshow("Captcha Processor", self.img)
+        cv2.waitKey(0)
+
+    @classmethod
+    def from_file_name(cls, name: str):
+        file = open(name, "rb")
+        processor = cls(file.read())
+        file.close()
+        return processor

main.py

@@ -0,0 +1,36 @@
+# import main things
+from fastapi import Depends, FastAPI, Body
+from fastapi.responses import JSONResponse, HTMLResponse
+from uvicorn import run
+from utils import predict   
+
+from fastapi_limiter import FastAPILimiter
+from fastapi_limiter.depends import RateLimiter
+
+import redis.asyncio as aioredis
+
+# initing things
+app = FastAPI()
+
+@app.on_event("startup")
+async def startup():
+    redis = aioredis.from_url("redis://localhost", encoding="utf-8", decode_responses=True)
+    await FastAPILimiter.init(redis)
+
+@app.get("/", dependencies=[Depends(RateLimiter(times=5, minutes=1))])
+@app.post("/", dependencies=[Depends(RateLimiter(times=5, minutes=1))])
+async def root():
+    return JSONResponse({"detail":"Not Found"}, 404)
+
+@app.get("/amino-captcha-ocr/api/v1/autoregister/version")
+async def v(): return {"v": 4, "l": ""}
+
+@app.get("/amino-captcha-ocr/api/v1/predict", dependencies=[Depends(RateLimiter(times=5, minutes=1))])
+async def resolveGet():
+    return JSONResponse({"detail":"Use POST instead GET"}, 400)
+
+@app.post("/amino-captcha-ocr/api/v1/predict", dependencies=[Depends(RateLimiter(times=5, minutes=1))])
+async def resolvePost(data = Body()):
+    return await predict(data["url"])
+    
+run(app, host="0.0.0.0", port=80)

model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:792c015158ffcfaadbb2a65fef9623af7fa1d243e3e1f915444f86c40049ea13
+size 3730536

utils.py

@@ -0,0 +1,137 @@
+from keras.models import load_model
+from aiohttp import ClientSession
+from numpy import expand_dims as np_expand_dims
+from captcha_processor import CaptchaProcessor
+from asyncio import get_running_loop
+from asyncio import sleep as asyncsleep
+from random import randint
+import aiofiles
+
+model = load_model("model.h5")
+proxies = [
+    #"http://q2adq9_proton_me:qwerty123123@la.residential.rayobyte.com:8000",
+    "http://ocjjjsgs:igbepiym05rl@95.164.235.50:6106"
+]
+
+async def get_binary_from_link(link: str) -> bytes:
+    async with ClientSession() as session:
+        for _ in range(20):
+            try:
+                a = await session.get(link, proxy=proxies[randint(0, len(proxies)-1)])
+                if int(a.status) == 200:
+                    print("Got binary")
+                    return await a.read()
+                else:
+                    await asyncsleep(0.125)
+            except Exception as e:
+                print(e)
+        return randint(100000, 999999)
+
+
+async def predict(url: str, recursion: int = 0, fnfnfn: int = randint(1, 10000000)) -> dict:
+    binary = await get_binary_from_link(url)
+    if type(binary) == type(0):
+        return {
+                "WARNING": "PROXY RETURNING INVALID IMAGE. CONTACT OWNER IMMEDIATLY.",
+                "prediction": binary,
+                "letters_predictions": "PROXY RETURNING INVALID IMAGE. CONTACT OWNER IMMEDIATLY.",
+                "full_prediction": binary,
+                "recursion": recursion
+            }
+    
+    async with aiofiles.open(f"/root/c-s-api/temp/{fnfnfn}.png", "wb") as outfile:
+        print(f"Trying to do smth with {fnfnfn}")
+        await outfile.write(binary)
+    
+    try:
+        processor = CaptchaProcessor(binary)
+    except Exception as e:
+        if recursion > 10:
+            return {
+                "WARNING": "PROXY RETURNING INVALID IMAGE. CONTACT OWNER IMMEDIATLY.",
+                "prediction": binary,
+                "letters_predictions": "PROXY RETURNING INVALID IMAGE. CONTACT OWNER IMMEDIATLY.",
+                "full_prediction": binary,
+                "recursion": recursion
+            }
+        else:
+            print(f"1, {recursion}, {str(e)}")
+            return await predict(url, recursion + 1, fnfnfn)
+    
+    try:
+        processor.replace_color(processor.get_background_color(), processor.WHITE_RGB)
+        processor.replace_colors(processor.get_letters_color(), processor.WHITE_RGB)
+    except Exception as e:
+        if recursion > 10:
+            return {
+                "WARNING": "SOMETHING WENT WRONG. CONTACT OWNER IMMEDIATLY.",
+                "prediction": binary,
+                "letters_predictions": "SOMETHING WENT WRONG. CONTACT OWNER IMMEDIATLY.",
+                "full_prediction": binary,
+                "recursion": recursion
+            }
+        else:
+            print(f"2, {recursion}, {str(e)}")
+            return await predict(url, recursion + 1, fnfnfn)
+    
+    try:
+        processor.convert_color_space(6)
+    except Exception as e:
+        if recursion > 10:
+            return {
+                "WARNING": "SOMETHING WENT WRONG. CONTACT OWNER IMMEDIATLY.",
+                "prediction": binary,
+                "letters_predictions": "SOMETHING WENT WRONG. CONTACT OWNER IMMEDIATLY.",
+                "full_prediction": binary,
+                "recursion": recursion
+            }
+        else:
+            print(f"3, {recursion}, {str(e)}")
+            return await predict(url, recursion + 1, fnfnfn)
+    
+    try:
+        processor.threshold()
+    except Exception as e:
+        if recursion > 10:
+            return {
+                "WARNING": "PROXY RETURNING INVALID IMAGE. CONTACT OWNER IMMEDIATLY.",
+                "prediction": binary,
+                "letters_predictions": "PROXY RETURNING INVALID IMAGE. CONTACT OWNER IMMEDIATLY.",
+                "full_prediction": binary,
+                "recursion": recursion
+            }
+        else:
+            print(f"4, {recursion}, {str(e)}")
+            return await predict(url, recursion + 1, fnfnfn)
+        
+    #    processor = CaptchaProcessor(binary)
+    #    processor.replace_color(processor.get_background_color(), processor.WHITE_RGB)
+    #    processor.replace_colors(processor.get_letters_color(), processor.WHITE_RGB)
+    #    processor.convert_color_space(6)
+    #    processor.threshold()
+    #except Exception as e:
+    #    print(f"error with image, trying again {e}")
+    #    return await predict(url, recursion + 1)
+        
+    try:
+        processor.increase_letters_size(2)
+    except IndexError:
+        return await predict(url, recursion + 1, fnfnfn)
+    letters = processor.slice_letters()
+    if len(letters) != 6: return await predict(url, recursion + 1, fnfnfn)
+    shorts = []
+    final = ""
+    letters_solving = [
+        get_running_loop().run_in_executor(None, model.predict, np_expand_dims(letter, axis=0))
+        for letter in letters
+    ]
+    letters_solving = [await result for result in letters_solving]
+    fulls = [list(map(lambda x: float(x), letter[0])) for letter in letters_solving]
+    for prediction in fulls: shorts.append(prediction.index(max(*prediction)))
+    for short in shorts: final += str(short)
+    return {
+        "prediction": final,
+        "letters_predictions": shorts,
+        "full_prediction": fulls,
+        "recursion": recursion
+    }