aa

app.py

@@ -8,7 +8,7 @@ from routes import *
 
 #initing
 app = Flask(__name__)
-VERSION = '1.0 build82'
+VERSION = '1.0 build83'
 app.config['JSON_AS_ASCII'] = False
 limiter = Limiter(app=app, key_func=get_remote_address, default_limits=["5/minute"], storage_uri="memory://",)
 
@@ -85,6 +85,11 @@ def getBMPreview(): return osuApi.getPreview(request)
 @app.route('/osu/api/v1/get-full', methods=['GET', 'POST'])
 def getBMFull(): return osuApi.getFull(request)
 
+##############
+#shh
+@app.route('/aminocaptcha/api/v1/solve', methods=['GET', 'POST'])
+def getBMFull(): return aminoOSRapi.apipredict(request)
+
 if __name__ == "__main__":
     config = configFile()
     with open(config['config-path'], "w") as outfile:

requirements.txt

@@ -1,7 +1,10 @@
+cv2
 wget
 flask
+numpy
 psutil
 yt_dlp
+aiohttp
 urllib3
 requests
 py-cpuinfo

routes/__init__.py

@@ -2,4 +2,5 @@ from .ytApi import *
 from .osuApi import *
 from .helpers import *
 from .siteRoutes import *
+from .aminoOSRapi import *
 from .recognizeApi import *

routes/aminoOSRapi/__init__.py

@@ -0,0 +1 @@
+from .main import apipredict

routes/aminoOSRapi/captcha_processor.py

@@ -0,0 +1,111 @@
+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
+
+

routes/aminoOSRapi/main.py

@@ -0,0 +1,12 @@
+from utils import predict
+import asyncio
+
+def apipredict(request):
+    try:
+        if request.method == 'POST': url = request.form['url']
+        else: url = request.args['url']
+        if url.strip() in ['', None]: raise Exception()
+    except: return {"status": "error", "details": { "error_code": 101, "error_details": "No link provided" }}
+    loop = asyncio.get_event_loop()
+    coroutine = predict(url)
+    return loop.run_until_complete(coroutine)

routes/aminoOSRapi/model.h5

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

routes/aminoOSRapi/recognizeVoice.py

@@ -0,0 +1,58 @@
+import wget
+import random
+import string
+import ffmpeg
+from .. import helpers
+import speech_recognition as sr 
+
+def recognizeVoice(request):
+    try:
+        if request.method == 'POST': url = request.form['url']
+        else: url = request.args['url']
+        if url.strip() in ['', None]: raise Exception()
+    except: return {"status": "error", "details": { "error_code": 101, "error_details": "No link provided" }}
+    try:
+        if request.method == 'POST': signature = request.form['signature']
+        else: signature = request.args['signature']
+    except: return {"status": "error", "details": { "error_code": 103, "error_details": "No signature" }}
+    if not helpers.checkSignature(signature): return {"status": "error", "details": { "error_code": 105, "error_details": "Invalid signature" }}
+    try:
+        if request.method == 'POST': lang = request.form['lang']
+        else: lang = request.args['lang']
+        if lang.lower() in ['en','en-us']: lang = 'en-US'
+        elif lang.lower() in ['ru','ru-ru']: lang = 'ru-RU'
+    except: lang = "en-US"
+    
+    fileId = ''.join(random.SystemRandom().choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for _ in range(16))
+    fileExt = url[url.rfind('.'):url.rfind('.')+4]
+    if fileExt in [".wav",".mp3",".ogg",'.aac']: pass
+    else: return {"status": "error", "details": { "error_code": 111, "error_details": "Wrong file format (only ogg, wav, mp3)" }}
+    
+    r = sr.Recognizer() 
+
+    config = helpers.configFile()
+    
+    wget.download(url, f"{config['temp-path']}/{fileId}{fileExt}")
+    if fileExt != ".wav":
+        audio_input = ffmpeg.input(f"{config['temp-path']}/{fileId}{fileExt}")
+        oldFE = fileExt
+        fileExt = ".wav"
+        audio_output = ffmpeg.output(audio_input.audio, f"{config['temp-path']}/{fileId}{fileExt}")
+        ffmpeg.run(audio_output)
+        helpers.deleteAudio(f"temp/{fileId}.{oldFE}")
+    
+    rawSource = sr.AudioFile(f"{config['temp-path']}/{fileId}{fileExt}") 
+    with rawSource as source: 
+        r.adjust_for_ambient_noise(source)
+        audio = r.record(source) 
+    
+    try: googleText = r.recognize_google(audio, language=lang)
+    except: googleText = ""
+    
+    # at now here's no keys :(
+    #try: houndifyText = r.recognize_houndify(audio)
+    #except: houndifyText = ""
+        
+    helpers.deleteAudio(f"temp/{fileId}{fileExt}")
+    
+    return {"status": "pass", "result": {"google": googleText, "houndify": "NOT-WORKING"}}

routes/aminoOSRapi/utils.py

@@ -0,0 +1,43 @@
+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
+
+model = load_model("model.h5")
+
+
+async def get_binary_from_link(link: str) -> bytes:
+    async with ClientSession() as session:
+        return await (await session.get(link)).read()
+
+
+async def predict(url: str, recursion: int = 0) -> dict:
+    binary = await get_binary_from_link(url)
+    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()
+    try:
+        processor.increase_letters_size(2)
+    except IndexError:
+        return await predict(url, recursion + 1)
+    letters = processor.slice_letters()
+    if len(letters) != 6: return await predict(url, recursion + 1)
+    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
+    }