Upload 3 files

agicto.py

@@ -0,0 +1,254 @@
+import bs4
+import time
+import requests
+import ipaddress
+
+
+BASE_URL = "https://api.agicto.cn/v1"
+API_KEYS = []
+REVOKE_KEYS = []
+
+
+class TempMail:
+    base_api = "https://www.1secmail.com/api/v1/"
+
+    def __init__(self):
+        self.mail: str = self.random_mail()
+
+    def __str__(self):
+        return self.mail
+
+    def random_mail(self):
+        return requests.get(
+            self.base_api, params={"action": "genRandomMailbox"}
+        ).json()[0]
+
+    def check_inbox(self):
+        mail, domain = self.mail.split("@")
+        mail = {"login": mail, "domain": domain}
+
+        inbox = requests.get(
+            self.base_api,
+            params={"action": "getMessages", **mail},
+        ).json()
+        if inbox:
+            inbox = requests.get(
+                self.base_api,
+                params={"action": "readMessage", "id": inbox[0]["id"], **mail},
+            )
+
+            return inbox.json()["body"]
+
+
+def generate_api_key() -> str:
+    mail = TempMail()
+
+    sess = requests.Session()
+    sess.headers.update(
+        {
+            "user-agent": (
+                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                "AppleWebKit/537.36 (KHTML, like Gecko) "
+                "Chrome/89.0.142.86 Safari/537.36"
+            ),
+            "x-forwarded-for": str(
+                ipaddress.IPv4Address(random.randint(0, (1 << 32) - 1))
+            ),
+        }
+    )
+    sess.post(
+        BASE_URL + "/sendVerifyCode",
+        json={"email": str(mail), "channel": ""},
+    )
+
+    step = 0
+    while step < 20:
+        inbox = mail.check_inbox()
+        if inbox:
+            break
+        time.sleep(1)
+        step += 1
+
+    if not inbox:
+        raise Exception("Failed to get inbox")
+
+    soup = bs4.BeautifulSoup(inbox, "html.parser")
+    code = soup.find("div", {"class": "code-box"}).text
+
+    token = sess.post(
+        BASE_URL + "/loginByCode",
+        json={
+            "email": str(mail),
+            "verify_code": code,
+            "invite_code": "",
+        },
+    ).json()["data"]["access_token"]
+
+    api_key = sess.post(
+        BASE_URL + "/service/keyList",
+        headers={
+            "authorization": f"Bearer {token}",
+        },
+    ).json()["data"]["recordList"][0]["openKey"]
+    return api_key
+
+
+import threading
+
+
+def increase_api_keys(max=6, per_thread=3):
+    if len(API_KEYS) < max:
+        threads = [
+            threading.Thread(target=lambda: API_KEYS.append(generate_api_key()))
+            for _ in range(per_thread)
+        ]
+        [t.start() for t in threads]
+
+
+import re
+import random
+import json
+
+from werkzeug import exceptions
+
+
+# non-stream
+def chat_completion(**kwargs):
+    sess = requests.Session()
+    for i in range(max_retries := 3):
+        try:
+            api_key = random.choice(API_KEYS)
+            sess.headers.update(
+                {
+                    "authorization": "Bearer " + api_key,
+                    "x-forwarded-for": str(
+                        ipaddress.IPv4Address(random.randint(0, (1 << 32) - 1))
+                    ),
+                },
+            )
+            r = sess.post(BASE_URL + "/chat/completions", json=kwargs, timeout=30)
+            r.raise_for_status()
+
+            if r.json().get("error"):
+                raise requests.exceptions.HTTPError(response=r)
+
+            break
+        except IndexError:
+            continue
+        except requests.exceptions.Timeout:
+            continue
+        except requests.exceptions.HTTPError as e:
+            try:
+                data = e.response.json()
+                if data.get("error") or data.get("code") == 1:
+                    msg = data.get("error", {}).get("message") or data.get("message")
+                    if re.search(r"agicto", msg, re.IGNORECASE):
+                        if api_key in API_KEYS:
+                            API_KEYS.remove(api_key)
+                            REVOKE_KEYS.append(api_key)
+                        continue
+
+                    raise exceptions.BadRequest(msg)
+            except json.JSONDecodeError:
+                pass
+
+    if i == max_retries - 1:
+        raise exceptions.ServiceUnavailable
+
+    try:
+        content: str = r.json()["choices"][0]["message"]["content"]
+        return bytes(content, "utf-8").decode("unicode_escape")
+    except:
+        raise exceptions.ServiceUnavailable
+
+
+# stream
+def chat_completion_stream(**kwargs):
+    kwargs["stream"] = True
+
+    sess = requests.Session()
+    for i in range(max_retries := 3):
+        try:
+            api_key = random.choice(API_KEYS)
+            sess.headers.update(
+                {
+                    "authorization": "Bearer " + api_key,
+                    "x-forwarded-for": str(
+                        ipaddress.IPv4Address(random.randint(0, (1 << 32) - 1))
+                    ),
+                },
+            )
+            r = sess.post(
+                BASE_URL + "/chat/completions", json=kwargs, stream=True, timeout=30
+            )
+            r.raise_for_status()
+            if "text/event-stream" not in r.headers.get("Content-Type"):
+                raise requests.exceptions.HTTPError(response=r)
+
+            break
+        except IndexError:
+            continue
+        except requests.exceptions.Timeout:
+            continue
+        except requests.exceptions.HTTPError as e:
+            try:
+                data = e.response.json()
+                if data.get("error") or data.get("code") == 1:
+                    msg = data.get("error", {}).get("message") or data.get("message")
+                    if re.search(r"agicto", msg, re.IGNORECASE):
+                        if api_key in API_KEYS:
+                            API_KEYS.remove(api_key)
+                            REVOKE_KEYS.append(api_key)
+                        continue
+
+                    raise exceptions.BadRequest(msg)
+            except json.JSONDecodeError:
+                pass
+
+    if i == max_retries - 1:
+        raise exceptions.ServiceUnavailable
+
+    init = True
+    for line in r.iter_lines():
+        line: bytes
+        if line:
+            try:
+                data: dict = json.loads(line.decode().removeprefix("data: "))
+            except json.JSONDecodeError:
+                continue
+
+            if choices := data.get("choices"):
+                delta: dict = choices[0]["delta"]
+                if delta := delta.get("content"):
+                    if init:
+                        init = False
+                        yield ""
+                    yield delta
+
+    if init:
+        raise exceptions.ServiceUnavailable
+
+
+if __name__ == "__main__":
+    print(generate_api_key())
+    exit(0)
+
+    increase_api_keys(per_thread=1)
+    while True:
+        if len(API_KEYS) == 0:
+            print("waiting for api key...")
+            time.sleep(1)
+        else:
+            print(f"{len(API_KEYS)} api keys available")
+            break
+
+    data = {
+        "model": "claude-3-opus-20240229",
+        "messages": [
+            {"role": "user", "content": "who are you?"},
+        ],
+    }
+
+    print("generating...")
+    for i in chat_completion_stream(**data):
+        print(i, end="")

app.py

@@ -0,0 +1,373 @@
+from flask import (
+    Flask,
+    Response,
+    request,
+    jsonify,
+    redirect,
+    url_for,
+    render_template,
+    stream_with_context,
+)
+from werkzeug import exceptions
+
+import os
+import logging
+
+exceptions.BadRequestKeyError.show_exception = True
+
+from werkzeug.middleware.proxy_fix import ProxyFix
+
+app = Flask(__name__, static_folder=None)
+app.json.sort_keys = False
+
+app.wsgi_app = ProxyFix(app.wsgi_app)
+
+from providers.agicto import (
+    chat_completion,
+    chat_completion_stream,
+    increase_api_keys,
+    API_KEYS,
+    REVOKE_KEYS,
+)
+
+# from providers.devcto import (
+#     chat_completion_stream,
+#     increase_api_keys,
+#     API_KEYS,
+#     REVOKE_KEYS,
+# )
+
+
+@app.route("/")
+def root():
+    return redirect(url_for("base_url"))
+
+
+import humanize
+import time
+
+UPTIME = time.time()
+WAITING = UPTIME
+LAST_UNAVAILABLE = None
+
+PROMPTERS = 0
+TOKENS = {"input": 0, "output": 0}
+
+RIDDLE_ID = os.environ.get("RIDDLE_ID", "-")
+RIDDLE_EN = os.environ.get("RIDDLE_EN", "-")
+RIDDLE_EXPIRE = os.environ.get("RIDDLE_EXPIRE", "?")
+
+SONG = {
+    "title": os.environ.get("SONG_TITLE", "-"),
+    "url": os.environ.get("SONG_URL", None),
+}
+
+
+@app.route("/v1")
+def base_url():
+    wait = max(0, WAITING - time.time())
+    info = {
+        "base_url": url_for("base_url", _external=True),
+        "api_key": "(riddle_word)",
+        "endpoints": [str(_) for _ in app.url_map.iter_rules()],
+        "usages": {
+            "tokens": {
+                "input": f"{humanize.intword(TOKENS['input'])} ($0.015 / 1k)",
+                "output": f"{humanize.intword(TOKENS['output'])} ($0.075 / 1k)",
+                "cost": f"${((TOKENS['input'] * 0.015) + (TOKENS['output'] * 0.075)) / 1000:,.2f}",
+            },
+            "keys": f"{len(API_KEYS)} stored | {len(REVOKE_KEYS)} revoked",
+        },
+        "details": {
+            "uptime": humanize.naturaldelta(time.time() - UPTIME),
+            "prompters": max(0, PROMPTERS),
+            "waiting": humanize.naturaldelta(wait) if wait else None,
+            "last_pantun": (
+                humanize.naturaltime(time.time() - LAST_UNAVAILABLE)
+                if LAST_UNAVAILABLE
+                else None
+            ),
+        },
+    }
+
+    if (
+        request.accept_mimetypes.accept_json
+        and not request.accept_mimetypes.accept_html
+    ):
+        return Response(json.dumps(info, indent=2), mimetype="application/json")
+
+    return render_template(
+        "index.html",
+        prompt=json.dumps(info, indent=2),
+        riddle=[RIDDLE_ID, RIDDLE_EN],
+        riddle_expire=RIDDLE_EXPIRE,
+        song=SONG,
+    )
+
+
+@app.teardown_request
+def teardown_request(_):
+    # only from messages
+    if request.endpoint == "messages":
+        global PROMPTERS, WAITING
+        if PROMPTERS > 0:
+            PROMPTERS -= 1
+
+
+@app.route("/v1/models")
+def models():
+    return jsonify(
+        {
+            "objects": "list",
+            "data": [
+                {
+                    "id": "claude-3-opus-20240229",
+                    "object": "chat.completion",
+                    "created": None,
+                    "owned_by": "anthropic",
+                }
+            ],
+        }
+    )
+
+
+API_KEY = [api_key.strip() for api_key in os.environ.get("API_KEY", "").split(",")]
+
+from marshmallow import schema, fields, validate, validates, ValidationError, EXCLUDE
+
+import random
+import string
+import json
+
+import tiktoken
+
+
+def count_tokens(input, output):
+    cl100k = tiktoken.get_encoding("cl100k_base")
+    input, output = len(cl100k.encode(input)), len(cl100k.encode(output))
+
+    global TOKENS
+    TOKENS["input"] += input
+    TOKENS["output"] += output
+
+    return {"input_tokens": input, "output_tokens": output}
+
+
+class MessageSchema(schema.Schema):
+    model = fields.Str()
+    messages = fields.List(
+        fields.Nested(
+            {
+                "role": fields.Str(
+                    required=True,
+                    validate=validate.OneOf(["user", "assistant"]),
+                ),
+                "content": fields.Raw(required=True),
+            }
+        ),
+        required=True,
+    )
+    max_tokens = fields.Int(validate=validate.Range(min=1, max=4096))
+    system = fields.Str(allow_none=True)
+    stream = fields.Bool(allow_none=True)
+    temperature = fields.Float(
+        validate=validate.Range(min=0.0, max=1.0), allow_none=True
+    )
+    # top_k = fields.Float(allow_nan=True)
+    top_p = fields.Float(allow_nan=True)
+
+    @validates("model")
+    def validate_model(self, value):
+        if value not in ["claude-3-opus-20240229"]:
+            raise exceptions.BadRequest("Model must be claude-3-opus-20240229.")
+
+    class Meta:
+        unknown = EXCLUDE
+
+
+@app.route("/v1/messages", methods=["POST"])
+def messages():
+    if request.headers.get("x-api-key") not in API_KEY:
+        raise exceptions.Unauthorized(
+            "Invalid api key, open and check base_url (%s) for more info."
+            % url_for("base_url", _external=True)
+        )
+
+    if WAITING > time.time():
+        raise exceptions.TooManyRequests(
+            "Waiting for %s, and try again."
+            % humanize.naturaldelta(WAITING - time.time())
+        )
+
+    try:
+        data: dict = MessageSchema().load(request.json)
+    except ValidationError as err:
+        raise exceptions.BadRequestKeyError(err.messages)
+
+    if data.get("system"):
+        data["messages"].insert(0, {"role": "system", "content": data.pop("system")})
+
+    head = {
+        "id": "msg_" + "".join(random.choices(string.hexdigits, k=15)),
+        "model": data["model"],
+        "type": "message",
+        "role": "assistant",
+        "stop_sequence": None,
+    }
+
+    # increase prompter
+    global PROMPTERS
+    PROMPTERS += 1
+
+    input = "".join([m["content"] for m in data["messages"]])
+
+    if data.get("stream"):
+        next(completion := chat_completion_stream(**data))
+
+        def chunk(data):
+            return "data: " + json.dumps(data, separators=(",", ":")) + "\n\n"
+
+        def generate():
+            yield bytes("event: message_start\n", "utf-8")
+            yield bytes(
+                chunk(
+                    {
+                        "type": "message_start",
+                        "message": {
+                            "content": [],
+                            **head,
+                            "stop_reason": None,
+                            "usage": {
+                                "input_tokens": None,
+                                "output_tokens": None,
+                            },
+                        },
+                    }
+                ),
+                "utf-8",
+            )
+            yield bytes("event: content_block_start\n", "utf-8")
+            yield bytes(
+                chunk(
+                    {
+                        "type": "content_block_start",
+                        "index": 0,
+                        "content_block": {"type": "text", "text": ""},
+                    }
+                ),
+                "utf-8",
+            )
+
+            output = ""
+            for _ in completion:
+                yield bytes("event: content_block_delta\n", "utf-8")
+                yield bytes(
+                    chunk(
+                        {
+                            "type": "content_block_delta",
+                            "index": 0,
+                            "delta": {"type": "text_delta", "text": _},
+                        }
+                    ),
+                    "utf-8",
+                )
+
+                output += _
+
+            yield bytes("event: content_block_stop\n", "utf-8")
+            yield bytes(
+                chunk({"type": "content_block_stop", "index": 0}),
+                "utf-8",
+            )
+
+            yield bytes("event: message_delta\n", "utf-8")
+            yield bytes(
+                chunk(
+                    {
+                        "type": "message_delta",
+                        "delta": {"stop_reason": "end_turn", "stop_sequence": None},
+                        "usage": count_tokens(input, output),
+                    }
+                ),
+                "utf-8",
+            )
+
+            yield bytes("event: message_stop\n", "utf-8")
+            yield bytes(chunk({"type": "message_stop"}), "utf-8")
+
+        return Response(stream_with_context(generate()), mimetype="text/event-stream")
+
+    output = chat_completion(**data)
+    return jsonify(
+        {
+            "content": [
+                {
+                    "text": output,
+                    "type": "text",
+                }
+            ],
+            **head,
+            "stop_reason": "end_turn",
+            "usage": count_tokens(input, output),
+        }
+    )
+
+
+import re
+import traceback
+
+
+@app.errorhandler(Exception)
+def handle_exception(_):
+    traceback.print_exc()
+    return handle_exception(exceptions.InternalServerError())
+
+
+UNAVAILABLE_MESSAGES = [
+    "Burung kenari terbang tinggi, Di taman bunga menari-nari. Kamu refresh gak ada henti, Tapi server-nya malah pergi!",
+    "Ke laut mancing ikan kerapu, Dapat satu langsung dilempar. Mau akses disuruh nunggu, Muncul service unavailable bikin kesal!",
+    "Beli donat rasa durian, Dimakan ramai-ramai di taman. Service unavailable datangnya seharian, Bikin hati jadi gak karuan!",
+    "Ke pasar beli terasi, Naik motor sambil bernyanyi. Server sibuk, coba lagi, Service unavailable nih hari!",
+    "Pagi-pagi minum teh manis, Disruput sambil lihat layar. Server down, jadi nangis, Error lagi, kapan lancar?",
+    "Pergi ke taman sambil joget, Liat kupu-kupu terbang santai. Mau refresh sampe capek, Servernya malah bilang bye-bye!",
+    "Ke pasar beli jeruk Bali, Eh ketemu sama teman lama. Klik refresh terus berkali-kali, Tapi servernya malah drama!",
+]
+
+
+@app.errorhandler(exceptions.ServiceUnavailable)
+def handle_unavailable(e: exceptions.ServiceUnavailable):
+    global LAST_UNAVAILABLE, WAITING
+    LAST_UNAVAILABLE = time.time()
+    WAITING = time.time() + random.randint(3, 10)
+    return handle_exception(
+        exceptions.ServiceUnavailable(random.choice(UNAVAILABLE_MESSAGES))
+    )
+
+
+@app.errorhandler(exceptions.HTTPException)
+def handle_exception(e: exceptions.HTTPException):
+    error = {
+        "error": {
+            "type": re.sub(r"([a-z])([A-Z])", r"\1_\2", e.__class__.__name__).lower(),
+            "message": e.description,
+            "code": e.code,
+        }
+    }
+    return jsonify(error), e.code
+
+
+if not app.debug:
+    from apscheduler.schedulers.background import BackgroundScheduler
+
+    scheduler = BackgroundScheduler()
+    scheduler.add_job(increase_api_keys, "interval", minutes=1)
+    scheduler.start()
+
+    import atexit
+
+    atexit.register(lambda: scheduler.shutdown())
+else:
+    logging.basicConfig(level=logging.DEBUG)
+
+    # testing
+    increase_api_keys(per_thread=1)

index.html

@@ -0,0 +1,169 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
+    <title>Opus :3</title>
+
+    <script src="https://cdn.tailwindcss.com"></script>
+</head>
+
+<body class="bg-gradient-to-b from-orange-900 to-black text-white select-none">
+    <div class="flex sm:justify-center sm:items-center min-h-screen">
+        <div class="sm:w-1/2 p-4">
+            <div>
+                <style>
+                    .blink-container {
+                        display: inline-block;
+                        position: relative;
+                        width: 1em;
+                        height: 1em;
+                    }
+
+                    .blink-container::before,
+                    .blink-container::after {
+                        content: '😗';
+                        position: absolute;
+                        top: 0;
+                        left: 0;
+                        width: 100%;
+                        height: 100%;
+                        display: flex;
+                        justify-content: center;
+                        align-items: center;
+                    }
+
+                    .blink-container::after {
+                        content: '😙';
+                        opacity: 0;
+                        animation: blink 3s infinite;
+                    }
+
+                    .blink-container:hover::before,
+                    .blink-container:hover::after {
+                        content: '😚';
+                    }
+
+                    @keyframes blink {
+
+                        0%,
+                        90% {
+                            opacity: 0;
+                        }
+
+                        91%,
+                        100% {
+                            opacity: 1;
+                        }
+                    }
+                </style>
+                <h1 class="text-4xl font-bold tracking-wider">
+                    dumb-<span class="blink-container mx-1 -mb-1"></span>pus
+                </h1>
+
+                <p class="mt-4">
+                    Claude 3 Opus is a language model developed by Anthropic that is considered to be their most
+                    capable.
+                </p>
+            </div>
+
+            <!-- riddle word -->
+            <div class="mt-8">
+                <p class="font-bold">Riddle <sup class="bg-white/10 px-1 rounded">{{ riddle_expire }}</sup> :</p>
+                <!-- button ID | EN -->
+                <div class="mt-2 flex gap-4">
+                    <label class="flex items-center">
+                        <input type="radio" class="mr-2" name="language" value="id" />
+                        ID
+                    </label>
+                    <label class="flex items-center">
+                        <input type="radio" class="mr-2" name="language" value="en" checked />
+                        EN
+                    </label>
+                </div>
+                <script>
+                    const radioButtons = document.querySelectorAll('input[name="language"]');
+                    radioButtons.forEach((radio) => {
+                        radio.addEventListener('change', (event) => {
+                            if (event.target.value === 'id') {
+                                document.getElementById('riddle_id').classList.remove('hidden');
+                                document.getElementById('riddle_en').classList.add('hidden');
+                            } else {
+                                document.getElementById('riddle_id').classList.add('hidden');
+                                document.getElementById('riddle_en').classList.remove('hidden');
+                            }
+                        });
+                    });
+                </script>
+
+                <div class="mt-4 cursor-help">
+                    <span class="text-xs text-white/30 flex items-center gap-1 py-2">
+                        <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5"
+                            stroke="currentColor" class="w-4 h-4">
+                            <path stroke-linecap="round" stroke-linejoin="round"
+                                d="m21 7.5-9-5.25L3 7.5m18 0-9 5.25m9-5.25v9l-9 5.25M3 7.5l9 5.25M3 7.5v9l9 5.25m0-9v9" />
+                        </svg>
+                        AI Generated
+                    </span>
+                    <pre id="riddle_id" class="font-sans hidden">{{ riddle[0] }}</pre>
+                    <pre id="riddle_en" class="font-sans">{{ riddle[1] }}</pre>
+                </div>
+            </div>
+
+            {% if song.url %}
+            <div class="mt-4 max-w-2xl relative">
+                <button class="absolute top-0 -right-1.5 p-2 bg-white text-black rounded-full"
+                    onclick="this.parentElement.remove()">
+                    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor"
+                        stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="w-4 h-4">
+                        <line x1="18" y1="6" x2="6" y2="18"></line>
+                        <line x1="6" y1="6" x2="18" y2="18"></line>
+                    </svg>
+                </button>
+                <fieldset class="border rounded-lg p-4">
+                    <legend class="mx-2 px-2">ads</legend>
+                    <p class="text-center">{{ song.title }}</p>
+                    <audio controls autoplay class="w-full my-2">
+                        <source src="{{ song.url }}" type="audio/mpeg">
+                    </audio>
+                </fieldset>
+            </div>
+            {% endif %}
+
+            <div class="mt-8 select-text">
+                <pre id="prompt" class="text-white">
+                    {%- if prompt -%}
+                    {{ prompt }}
+                    {%- endif -%}
+                </pre>
+            </div>
+
+            <footer class="mt-6">
+                <p class="text-sm text-white/50">
+                    made with 🐈 by <span class="font-bold">dakunesu</span>, support me on
+                    <a class="font-bold" target="_blank" href="https://sociabuzz.com/dakunesu/support">
+                        <span class="text-green-500">socia</span><span class="text-blue-500">buzz</span>
+                    </a>
+                </p>
+            </footer>
+        </div>
+    </div>
+
+    <script>
+        const url = new URL(window.location.href);
+        // every 10 seconds, fetch info
+        setInterval(() => {
+            fetch(url, { headers: { "accept": "application/json" } })
+                .then((res) => res.text())
+                .then((text) => {
+                    document.getElementById("prompt").innerHTML = text;
+                })
+                .catch((err) => {
+                    console.log(err);
+                });
+        }, 10000);
+    </script>
+</body>
+
+</html>