Upload 7 files

.gitattributes

@@ -25,7 +25,6 @@
 *.safetensors filter=lfs diff=lfs merge=lfs -text
 saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
 *.tflite filter=lfs diff=lfs merge=lfs -text
 *.tgz filter=lfs diff=lfs merge=lfs -text
 *.wasm filter=lfs diff=lfs merge=lfs -text

EdgeGPT.py

@@ -0,0 +1,1293 @@
+"""
+Main.py
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import aiofiles
+import json
+import os
+import random
+import re
+import ssl
+import sys
+import time
+import uuid
+from enum import Enum
+from pathlib import Path
+from typing import Generator
+
+try:
+    from typing import Literal
+except ImportError:
+    from typing_extensions import Literal
+from typing import Optional
+from typing import Union
+
+import aiohttp
+import certifi
+import httpx
+from BingImageCreator import ImageGen
+from BingImageCreator import ImageGenAsync
+from prompt_toolkit import PromptSession
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.history import InMemoryHistory
+from prompt_toolkit.key_binding import KeyBindings
+from rich.live import Live
+from rich.markdown import Markdown
+
+DELIMITER = "\x1e"
+
+
+# Generate random IP between range 13.104.0.0/14
+FORWARDED_IP = (
+    f"13.{random.randint(104, 107)}.{random.randint(0, 255)}.{random.randint(0, 255)}"
+)
+
+HEADERS = {
+    "accept": "application/json",
+    "accept-language": "en-US,en;q=0.9",
+    "content-type": "application/json",
+    "sec-ch-ua": '"Not_A Brand";v="99", "Microsoft Edge";v="110", "Chromium";v="110"',
+    "sec-ch-ua-arch": '"x86"',
+    "sec-ch-ua-bitness": '"64"',
+    "sec-ch-ua-full-version": '"109.0.1518.78"',
+    "sec-ch-ua-full-version-list": '"Chromium";v="110.0.5481.192", "Not A(Brand";v="24.0.0.0", "Microsoft Edge";v="110.0.1587.69"',
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-model": "",
+    "sec-ch-ua-platform": '"Windows"',
+    "sec-ch-ua-platform-version": '"15.0.0"',
+    "sec-fetch-dest": "empty",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-site": "same-origin",
+    "x-ms-client-request-id": str(uuid.uuid4()),
+    "x-ms-useragent": "azsdk-js-api-client-factory/1.0.0-beta.1 core-rest-pipeline/1.10.0 OS/Win32",
+    "Referer": "https://www.bing.com/search?q=Bing+AI&showconv=1&FORM=hpcodx",
+    "Referrer-Policy": "origin-when-cross-origin",
+    "x-forwarded-for": FORWARDED_IP,
+}
+
+HEADERS_INIT_CONVER = {
+    "authority": "edgeservices.bing.com",
+    "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+    "accept-language": "en-US,en;q=0.9",
+    "cache-control": "max-age=0",
+    "sec-ch-ua": '"Chromium";v="110", "Not A(Brand";v="24", "Microsoft Edge";v="110"',
+    "sec-ch-ua-arch": '"x86"',
+    "sec-ch-ua-bitness": '"64"',
+    "sec-ch-ua-full-version": '"110.0.1587.69"',
+    "sec-ch-ua-full-version-list": '"Chromium";v="110.0.5481.192", "Not A(Brand";v="24.0.0.0", "Microsoft Edge";v="110.0.1587.69"',
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-model": '""',
+    "sec-ch-ua-platform": '"Windows"',
+    "sec-ch-ua-platform-version": '"15.0.0"',
+    "sec-fetch-dest": "document",
+    "sec-fetch-mode": "navigate",
+    "sec-fetch-site": "none",
+    "sec-fetch-user": "?1",
+    "upgrade-insecure-requests": "1",
+    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36 Edg/110.0.1587.69",
+    "x-edge-shopping-flag": "1",
+    "x-forwarded-for": FORWARDED_IP,
+}
+
+ssl_context = ssl.create_default_context()
+ssl_context.load_verify_locations(certifi.where())
+
+
+class NotAllowedToAccess(Exception):
+    pass
+
+
+class LocationHint(Enum):
+    USA = {
+        "locale": "en-US",
+        "LocationHint": [
+            {
+                "country": "United States",
+                "state": "California",
+                "city": "Los Angeles",
+                "timezoneoffset": 8,
+                "countryConfidence": 8,
+                "Center": {
+                    "Latitude": 34.0536909,
+                    "Longitude": -118.242766,
+                },
+                "RegionType": 2,
+                "SourceType": 1,
+            }
+        ],
+    }
+    CHINA = {
+        "locale": "zh-CN",
+        "LocationHint": [
+            {
+                "country": "China",
+                "state": "",
+                "city": "Beijing",
+                "timezoneoffset": 8,
+                "countryConfidence": 8,
+                "Center": {
+                    "Latitude": 39.9042,
+                    "Longitude": 116.4074,
+                },
+                "RegionType": 2,
+                "SourceType": 1,
+            }
+        ],
+    }
+    EU = {
+        "locale": "en-IE",
+        "LocationHint": [
+            {
+                "country": "Norway",
+                "state": "",
+                "city": "Oslo",
+                "timezoneoffset": 1,
+                "countryConfidence": 8,
+                "Center": {
+                    "Latitude": 59.9139,
+                    "Longitude": 10.7522,
+                },
+                "RegionType": 2,
+                "SourceType": 1,
+            }
+        ],
+    }
+    UK = {
+        "locale": "en-GB",
+        "LocationHint": [
+            {
+                "country": "United Kingdom",
+                "state": "",
+                "city": "London",
+                "timezoneoffset": 0,
+                "countryConfidence": 8,
+                "Center": {
+                    "Latitude": 51.5074,
+                    "Longitude": -0.1278,
+                },
+                "RegionType": 2,
+                "SourceType": 1,
+            },
+        ],
+    }
+
+
+LOCATION_HINT_TYPES = Optional[Union[LocationHint, Literal["USA", "CHINA", "EU", "UK"]]]
+
+
+def get_location_hint_from_locale(locale: str) -> dict | None:
+    locale = locale.lower()
+    if locale == "en-us":
+        return LocationHint.USA.value
+    elif locale == "zh-cn":
+        return LocationHint.CHINA.value
+    elif locale == "en-gb":
+        return LocationHint.UK.value
+    elif locale == "en-ie":
+        return LocationHint.EU.value
+    else:
+        return None
+
+
+class ConversationStyle(Enum):
+    creative = [
+        "nlu_direct_response_filter",
+        "deepleo",
+        "disable_emoji_spoken_text",
+        "responsible_ai_policy_235",
+        "enablemm",
+        "h3imaginative",
+        "cachewriteext",
+        "e2ecachewrite",
+        "nodlcpcwrite",
+        "nointernalsugg",
+        "saharasugg",
+        "enablenewsfc",
+        "dv3sugg",
+        "clgalileo",
+        "gencontentv3",
+        "nojbfedge",
+    ]
+    balanced = [
+        "nlu_direct_response_filter",
+        "deepleo",
+        "disable_emoji_spoken_text",
+        "responsible_ai_policy_235",
+        "enablemm",
+        "harmonyv3",
+        "cachewriteext",
+        "e2ecachewrite",
+        "nodlcpcwrite",
+        "nointernalsugg",
+        "saharasugg",
+        "enablenewsfc",
+        "dv3sugg",
+        "nojbfedge",
+    ]
+    precise = [
+        "nlu_direct_response_filter",
+        "deepleo",
+        "disable_emoji_spoken_text",
+        "responsible_ai_policy_235",
+        "enablemm",
+        "h3precise",
+        "cachewriteext",
+        "e2ecachewrite",
+        "nodlcpcwrite",
+        "nointernalsugg",
+        "saharasugg",
+        "enablenewsfc",
+        "dv3sugg",
+        "clgalileo",
+        "gencontentv3",
+        "nojbfedge",
+    ]
+
+
+CONVERSATION_STYLE_TYPE = Optional[
+    Union[ConversationStyle, Literal["creative", "balanced", "precise"]]
+]
+
+
+def _append_identifier(msg: dict) -> str:
+    """
+    Appends special character to end of message to identify end of message
+    """
+    # Convert dict to json string
+    return json.dumps(msg, ensure_ascii=False) + DELIMITER
+
+
+def _get_ran_hex(length: int = 32) -> str:
+    """
+    Returns random hex string
+    """
+    return "".join(random.choice("0123456789abcdef") for _ in range(length))
+
+
+class _ChatHubRequest:
+    """
+    Request object for ChatHub
+    """
+
+    def __init__(
+        self,
+        conversation_signature: str,
+        client_id: str,
+        conversation_id: str,
+        invocation_id: int = 0,
+    ) -> None:
+        self.struct: dict = {}
+
+        self.client_id: str = client_id
+        self.conversation_id: str = conversation_id
+        self.conversation_signature: str = conversation_signature
+        self.invocation_id: int = invocation_id
+
+    def update(
+        self,
+        prompt: str,
+        conversation_style: CONVERSATION_STYLE_TYPE,
+        options: list | None = None,
+        webpage_context: str | None = None,
+        search_result: bool = False,
+        locale: str = "en-US",
+    ) -> None:
+        """
+        Updates request object
+        """
+        if options is None:
+            options = [
+                "deepleo",
+                "enable_debug_commands",
+                "disable_emoji_spoken_text",
+                "enablemm",
+            ]
+        if conversation_style:
+            if not isinstance(conversation_style, ConversationStyle):
+                conversation_style = getattr(ConversationStyle, conversation_style)
+            options = conversation_style.value
+        self.struct = {
+            "arguments": [
+                {
+                    "source": "cib",
+                    "optionsSets": options,
+                    "allowedMessageTypes": [
+                        "Chat",
+                        "Disengaged",
+                        "AdsQuery",
+                        "SemanticSerp",
+                        "GenerateContentQuery",
+                        "SearchQuery",
+                        "ActionRequest",
+                        "Context",
+                        "Progress",
+                        "AdsQuery",
+                        "SemanticSerp",
+                    ],
+                    "sliceIds": [
+                        "winmuid3tf",
+                        "osbsdusgreccf",
+                        "ttstmout",
+                        "crchatrev",
+                        "winlongmsgtf",
+                        "ctrlworkpay",
+                        "norespwtf",
+                        "tempcacheread",
+                        "temptacache",
+                        "505scss0",
+                        "508jbcars0",
+                        "515enbotdets0",
+                        "5082tsports",
+                        "515vaoprvs",
+                        "424dagslnv1s0",
+                        "kcimgattcf",
+                        "427startpms0",
+                    ],
+                    "traceId": _get_ran_hex(32),
+                    "isStartOfSession": self.invocation_id == 0,
+                    "message": {
+                        "locale": locale,
+                        "market": locale,
+                        "region": locale[-2:],  # en-US -> US
+                        "locationHints": [get_location_hint_from_locale(locale)],
+                        "author": "user",
+                        "inputMethod": "Keyboard",
+                        "text": prompt,
+                        "messageType": "Chat",
+                    },
+                    "conversationSignature": self.conversation_signature,
+                    "participant": {
+                        "id": self.client_id,
+                    },
+                    "conversationId": self.conversation_id,
+                },
+            ],
+            "invocationId": str(self.invocation_id),
+            "target": "chat",
+            "type": 4,
+        }
+        if search_result:
+            have_search_result = [
+                "InternalSearchQuery",
+                "InternalSearchResult",
+                "InternalLoaderMessage",
+                "RenderCardRequest",
+            ]
+            self.struct["arguments"][0]["allowedMessageTypes"] += have_search_result
+        if webpage_context:
+            self.struct["arguments"][0]["previousMessages"] = [
+                {
+                    "author": "user",
+                    "description": webpage_context,
+                    "contextType": "WebPage",
+                    "messageType": "Context",
+                    "messageId": "discover-web--page-ping-mriduna-----",
+                },
+            ]
+        self.invocation_id += 1
+
+
+class _Conversation:
+    """
+    Conversation API
+    """
+
+    def __init__(
+        self,
+        proxy: str | None = None,
+        async_mode: bool = False,
+        cookies: list[dict] | None = None,
+    ) -> None:
+        if async_mode:
+            return
+        self.struct: dict = {
+            "conversationId": None,
+            "clientId": None,
+            "conversationSignature": None,
+            "result": {"value": "Success", "message": None},
+        }
+        self.proxy = proxy
+        proxy = (
+            proxy
+            or os.environ.get("all_proxy")
+            or os.environ.get("ALL_PROXY")
+            or os.environ.get("https_proxy")
+            or os.environ.get("HTTPS_PROXY")
+            or None
+        )
+        if proxy is not None and proxy.startswith("socks5h://"):
+            proxy = "socks5://" + proxy[len("socks5h://") :]
+        self.session = httpx.Client(
+            proxies=proxy,
+            timeout=900,
+            headers=HEADERS_INIT_CONVER,
+        )
+        if cookies:
+            for cookie in cookies:
+                self.session.cookies.set(cookie["name"], cookie["value"])
+        # Send GET request
+        response = self.session.get(
+            url=os.environ.get("BING_PROXY_URL")
+            or "https://edgeservices.bing.com/edgesvc/turing/conversation/create",
+        )
+        if response.status_code != 200:
+            response = self.session.get(
+                "https://edge.churchless.tech/edgesvc/turing/conversation/create",
+            )
+        if response.status_code != 200:
+            print(f"Status code: {response.status_code}")
+            print(response.text)
+            print(response.url)
+            raise Exception("Authentication failed")
+        try:
+            self.struct = response.json()
+        except (json.decoder.JSONDecodeError, NotAllowedToAccess) as exc:
+            raise Exception(
+                "Authentication failed. You have not been accepted into the beta.",
+            ) from exc
+        if self.struct["result"]["value"] == "UnauthorizedRequest":
+            raise NotAllowedToAccess(self.struct["result"]["message"])
+
+    @staticmethod
+    async def create(
+        proxy: str | None = None,
+        cookies: list[dict] | None = None,
+    ) -> _Conversation:
+        self = _Conversation(async_mode=True)
+        self.struct = {
+            "conversationId": None,
+            "clientId": None,
+            "conversationSignature": None,
+            "result": {"value": "Success", "message": None},
+        }
+        self.proxy = proxy
+        proxy = (
+            proxy
+            or os.environ.get("all_proxy")
+            or os.environ.get("ALL_PROXY")
+            or os.environ.get("https_proxy")
+            or os.environ.get("HTTPS_PROXY")
+            or None
+        )
+        if proxy is not None and proxy.startswith("socks5h://"):
+            proxy = "socks5://" + proxy[len("socks5h://") :]
+        transport = httpx.AsyncHTTPTransport(retries=900)
+        # Convert cookie format to httpx format
+        formatted_cookies = None
+        if cookies:
+            formatted_cookies = httpx.Cookies()
+            for cookie in cookies:
+                formatted_cookies.set(cookie["name"], cookie["value"])
+        async with httpx.AsyncClient(
+            proxies=proxy,
+            timeout=30,
+            headers=HEADERS_INIT_CONVER,
+            transport=transport,
+            cookies=formatted_cookies,
+        ) as client:
+            # Send GET request
+            response = await client.get(
+                url=os.environ.get("BING_PROXY_URL")
+                or "https://edgeservices.bing.com/edgesvc/turing/conversation/create",
+            )
+            if response.status_code != 200:
+                response = await client.get(
+                    "https://edge.churchless.tech/edgesvc/turing/conversation/create",
+                )
+        if response.status_code != 200:
+            print(f"Status code: {response.status_code}")
+            print(response.text)
+            print(response.url)
+            raise Exception("Authentication failed")
+        try:
+            self.struct = response.json()
+        except (json.decoder.JSONDecodeError, NotAllowedToAccess) as exc:
+            raise Exception(
+                "Authentication failed. You have not been accepted into the beta.",
+            ) from exc
+        if self.struct["result"]["value"] == "UnauthorizedRequest":
+            raise NotAllowedToAccess(self.struct["result"]["message"])
+        return self
+
+
+class _ChatHub:
+    """
+    Chat API
+    """
+
+    def __init__(
+        self,
+        conversation: _Conversation,
+        proxy: str = None,
+        cookies: list[dict] | None = None,
+    ) -> None:
+        self.session: aiohttp.ClientSession | None = None
+        self.wss: aiohttp.ClientWebSocketResponse | None = None
+        self.request: _ChatHubRequest
+        self.loop: bool
+        self.task: asyncio.Task
+        self.request = _ChatHubRequest(
+            conversation_signature=conversation.struct["conversationSignature"],
+            client_id=conversation.struct["clientId"],
+            conversation_id=conversation.struct["conversationId"],
+        )
+        self.cookies = cookies
+        self.proxy: str = proxy
+
+    async def ask_stream(
+        self,
+        prompt: str,
+        wss_link: str,
+        conversation_style: CONVERSATION_STYLE_TYPE = None,
+        raw: bool = False,
+        options: dict = None,
+        webpage_context: str | None = None,
+        search_result: bool = False,
+        locale: str = "en-US",
+    ) -> Generator[str, None, None]:
+        """
+        Ask a question to the bot
+        """
+        timeout = aiohttp.ClientTimeout(total=900)
+        self.session = aiohttp.ClientSession(timeout=timeout)
+
+        if self.wss and not self.wss.closed:
+            await self.wss.close()
+        # Check if websocket is closed
+        self.wss = await self.session.ws_connect(
+            wss_link,
+            headers=HEADERS,
+            ssl=ssl_context,
+            proxy=self.proxy,
+            autoping=False,
+        )
+        await self._initial_handshake()
+        if self.request.invocation_id == 0:
+            # Construct a ChatHub request
+            self.request.update(
+                prompt=prompt,
+                conversation_style=conversation_style,
+                options=options,
+                webpage_context=webpage_context,
+                search_result=search_result,
+                locale=locale,
+            )
+        else:
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    "https://sydney.bing.com/sydney/UpdateConversation/",
+                    json={
+                        "messages": [
+                            {
+                                "author": "user",
+                                "description": webpage_context,
+                                "contextType": "WebPage",
+                                "messageType": "Context",
+                            },
+                        ],
+                        "conversationId": self.request.conversation_id,
+                        "source": "cib",
+                        "traceId": _get_ran_hex(32),
+                        "participant": {"id": self.request.client_id},
+                        "conversationSignature": self.request.conversation_signature,
+                    },
+                )
+            if response.status_code != 200:
+                print(f"Status code: {response.status_code}")
+                print(response.text)
+                print(response.url)
+                raise Exception("Update web page context failed")
+            # Construct a ChatHub request
+            self.request.update(
+                prompt=prompt,
+                conversation_style=conversation_style,
+                options=options,
+            )
+        # Send request
+        await self.wss.send_str(_append_identifier(self.request.struct))
+        final = False
+        draw = False
+        resp_txt = ""
+        result_text = ""
+        resp_txt_no_link = ""
+        while not final:
+            msg = await self.wss.receive(timeout=900)
+            objects = msg.data.split(DELIMITER)
+            for obj in objects:
+                if obj is None or not obj:
+                    continue
+                response = json.loads(obj)
+                if response.get("type") != 2 and raw:
+                    yield False, response
+                elif response.get("type") == 1 and response["arguments"][0].get(
+                    "messages",
+                ):
+                    if not draw:
+                        if (
+                            response["arguments"][0]["messages"][0].get("messageType")
+                            == "GenerateContentQuery"
+                        ):
+                            async with ImageGenAsync("", True) as image_generator:
+                                images = await image_generator.get_images(
+                                    response["arguments"][0]["messages"][0]["text"],
+                                )
+                            for i, image in enumerate(images):
+                                resp_txt = resp_txt + f"\n![image{i}]({image})"
+                            draw = True
+                        if (
+                            response["arguments"][0]["messages"][0]["contentOrigin"]
+                            != "Apology"
+                        ) and not draw:
+                            resp_txt = result_text + response["arguments"][0][
+                                "messages"
+                            ][0]["adaptiveCards"][0]["body"][0].get("text", "")
+                            resp_txt_no_link = result_text + response["arguments"][0][
+                                "messages"
+                            ][0].get("text", "")
+                            if response["arguments"][0]["messages"][0].get(
+                                "messageType",
+                            ):
+                                resp_txt = (
+                                    resp_txt
+                                    + response["arguments"][0]["messages"][0][
+                                        "adaptiveCards"
+                                    ][0]["body"][0]["inlines"][0].get("text")
+                                    + "\n"
+                                )
+                                result_text = (
+                                    result_text
+                                    + response["arguments"][0]["messages"][0][
+                                        "adaptiveCards"
+                                    ][0]["body"][0]["inlines"][0].get("text")
+                                    + "\n"
+                                )
+                        yield False, resp_txt
+
+                elif response.get("type") == 2:
+                    if response["item"]["result"].get("error"):
+                        await self.close()
+                        raise Exception(
+                            f"{response['item']['result']['value']}: {response['item']['result']['message']}",
+                        )
+                    if draw:
+                        cache = response["item"]["messages"][1]["adaptiveCards"][0][
+                            "body"
+                        ][0]["text"]
+                        response["item"]["messages"][1]["adaptiveCards"][0]["body"][0][
+                            "text"
+                        ] = (cache + resp_txt)
+                    if (
+                        response["item"]["messages"][-1]["contentOrigin"] == "Apology"
+                        and resp_txt
+                    ):
+                        response["item"]["messages"][-1]["text"] = resp_txt_no_link
+                        response["item"]["messages"][-1]["adaptiveCards"][0]["body"][0][
+                            "text"
+                        ] = resp_txt
+                        print(
+                            "Preserved the message from being deleted",
+                            file=sys.stderr,
+                        )
+                    final = True
+                    await self.close()
+                    yield True, response
+
+    async def _initial_handshake(self) -> None:
+        await self.wss.send_str(_append_identifier({"protocol": "json", "version": 1}))
+        await self.wss.receive(timeout=900)
+
+    async def close(self) -> None:
+        """
+        Close the connection
+        """
+        if self.wss and not self.wss.closed:
+            await self.wss.close()
+        if self.session and not self.session.closed:
+            await self.session.close()
+
+
+class Chatbot:
+    """
+    Combines everything to make it seamless
+    """
+
+    def __init__(
+        self,
+        proxy: str | None = None,
+        cookies: list[dict] | None = None,
+    ) -> None:
+        self.proxy: str | None = proxy
+        self.chat_hub: _ChatHub = _ChatHub(
+            _Conversation(self.proxy, cookies=cookies),
+            proxy=self.proxy,
+            cookies=cookies,
+        )
+
+    @staticmethod
+    async def create(
+        proxy: str | None = None,
+        cookies: list[dict] | None = None,
+    ):
+        self = Chatbot.__new__(Chatbot)
+        self.proxy = proxy
+        self.chat_hub = _ChatHub(
+            await _Conversation.create(self.proxy, cookies=cookies),
+            proxy=self.proxy,
+            cookies=cookies,
+        )
+        return self
+
+    async def save_conversation(self, filename: str) -> None:
+        """
+        Save the conversation to a file
+        """
+        async with aiofiles.open(filename, "w") as f:
+            f.write(json.dumps(self.chat_hub.struct))
+
+    async def load_conversation(self, filename: str) -> None:
+        """
+        Load the conversation from a file
+        """
+        async with aiofiles.open(filename, "r") as f:
+            self.chat_hub.struct = json.loads(await f.read())
+
+    async def ask(
+        self,
+        prompt: str,
+        wss_link: str = "wss://sydney.bing.com/sydney/ChatHub",
+        conversation_style: CONVERSATION_STYLE_TYPE = None,
+        options: dict = None,
+        webpage_context: str | None = None,
+        search_result: bool = False,
+        locale: str = "en-US",
+    ) -> dict:
+        """
+        Ask a question to the bot
+        """
+        async for final, response in self.chat_hub.ask_stream(
+            prompt=prompt,
+            conversation_style=conversation_style,
+            wss_link=wss_link,
+            options=options,
+            webpage_context=webpage_context,
+            search_result=search_result,
+            locale=locale,
+        ):
+            if final:
+                return response
+        await self.chat_hub.wss.close()
+        return {}
+
+    async def ask_stream(
+        self,
+        prompt: str,
+        wss_link: str = "wss://sydney.bing.com/sydney/ChatHub",
+        conversation_style: CONVERSATION_STYLE_TYPE = None,
+        raw: bool = False,
+        options: dict = None,
+        webpage_context: str | None = None,
+        search_result: bool = False,
+        locale: str = "en-US",
+    ) -> Generator[str, None, None]:
+        """
+        Ask a question to the bot
+        """
+        async for response in self.chat_hub.ask_stream(
+            prompt=prompt,
+            conversation_style=conversation_style,
+            wss_link=wss_link,
+            raw=raw,
+            options=options,
+            webpage_context=webpage_context,
+            search_result=search_result,
+            locale=locale,
+        ):
+            yield response
+
+    async def close(self) -> None:
+        """
+        Close the connection
+        """
+        await self.chat_hub.close()
+
+    async def reset(self) -> None:
+        """
+        Reset the conversation
+        """
+        await self.close()
+        self.chat_hub = _ChatHub(
+            await _Conversation.create(self.proxy, cookies=self.chat_hub.cookies),
+            proxy=self.proxy,
+            cookies=self.chat_hub.cookies,
+        )
+
+
+async def _get_input_async(
+    session: PromptSession = None,
+    completer: WordCompleter = None,
+) -> str:
+    """
+    Multiline input function.
+    """
+    return await session.prompt_async(
+        completer=completer,
+        multiline=True,
+        auto_suggest=AutoSuggestFromHistory(),
+    )
+
+
+def _create_session() -> PromptSession:
+    kb = KeyBindings()
+
+    @kb.add("enter")
+    def _(event):
+        buffer_text = event.current_buffer.text
+        if buffer_text.startswith("!"):
+            event.current_buffer.validate_and_handle()
+        else:
+            event.current_buffer.insert_text("\n")
+
+    @kb.add("escape")
+    def _(event):
+        if event.current_buffer.complete_state:
+            # event.current_buffer.cancel_completion()
+            event.current_buffer.text = ""
+
+    return PromptSession(key_bindings=kb, history=InMemoryHistory())
+
+
+def _create_completer(commands: list, pattern_str: str = "$"):
+    return WordCompleter(words=commands, pattern=re.compile(pattern_str))
+
+
+def _create_history_logger(f):
+    def logger(*args, **kwargs):
+        tmp = sys.stdout
+        sys.stdout = f
+        print(*args, **kwargs, flush=True)
+        sys.stdout = tmp
+
+    return logger
+
+
+async def async_main(args: argparse.Namespace) -> None:
+    """
+    Main function
+    """
+    print("Initializing...")
+    print("Enter `alt+enter` or `escape+enter` to send a message")
+    # Read and parse cookies
+    cookies = None
+    if args.cookie_file:
+        cookies = json.loads(open(args.cookie_file, encoding="utf-8").read())
+    bot = await Chatbot.create(proxy=args.proxy, cookies=cookies)
+    session = _create_session()
+    completer = _create_completer(["!help", "!exit", "!reset"])
+    initial_prompt = args.prompt
+
+    # Log chat history
+    def p_hist(*args, **kwargs):
+        pass
+
+    if args.history_file:
+        f = open(args.history_file, "a+", encoding="utf-8")
+        p_hist = _create_history_logger(f)
+
+    while True:
+        print("\nYou:")
+        p_hist("\nYou:")
+        if initial_prompt:
+            question = initial_prompt
+            print(question)
+            initial_prompt = None
+        else:
+            question = (
+                input()
+                if args.enter_once
+                else await _get_input_async(session=session, completer=completer)
+            )
+        print()
+        p_hist(question + "\n")
+        if question == "!exit":
+            break
+        if question == "!help":
+            print(
+                """
+            !help - Show this help message
+            !exit - Exit the program
+            !reset - Reset the conversation
+            """,
+            )
+            continue
+        if question == "!reset":
+            await bot.reset()
+            continue
+        print("Bot:")
+        p_hist("Bot:")
+        if args.no_stream:
+            response = (
+                await bot.ask(
+                    prompt=question,
+                    conversation_style=args.style,
+                    wss_link=args.wss_link,
+                    search_result=args.search_result,
+                    locale=args.locale,
+                )
+            )["item"]["messages"][1]["adaptiveCards"][0]["body"][0]["text"]
+            print(response)
+            p_hist(response)
+        else:
+            wrote = 0
+            if args.rich:
+                md = Markdown("")
+                with Live(md, auto_refresh=False) as live:
+                    async for final, response in bot.ask_stream(
+                        prompt=question,
+                        conversation_style=args.style,
+                        wss_link=args.wss_link,
+                        search_result=args.search_result,
+                        locale=args.locale,
+                    ):
+                        if not final:
+                            if not wrote:
+                                p_hist(response, end="")
+                            else:
+                                p_hist(response[wrote:], end="")
+                            if wrote > len(response):
+                                print(md)
+                                print(Markdown("***Bing revoked the response.***"))
+                            wrote = len(response)
+                            md = Markdown(response)
+                            live.update(md, refresh=True)
+            else:
+                async for final, response in bot.ask_stream(
+                    prompt=question,
+                    conversation_style=args.style,
+                    wss_link=args.wss_link,
+                    search_result=args.search_result,
+                    locale=args.locale,
+                ):
+                    if not final:
+                        if not wrote:
+                            print(response, end="", flush=True)
+                            p_hist(response, end="")
+                        else:
+                            print(response[wrote:], end="", flush=True)
+                            p_hist(response[wrote:], end="")
+                        wrote = len(response)
+                print()
+                p_hist()
+    if args.history_file:
+        f.close()
+    await bot.close()
+
+
+def main() -> None:
+    print(
+        """
+        EdgeGPT - A demo of reverse engineering the Bing GPT chatbot
+        Repo: github.com/acheong08/EdgeGPT
+        By: Antonio Cheong
+
+        !help for help
+
+        Type !exit to exit
+    """,
+    )
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--enter-once", action="store_true")
+    parser.add_argument("--search-result", action="store_true")
+    parser.add_argument("--no-stream", action="store_true")
+    parser.add_argument("--rich", action="store_true")
+    parser.add_argument(
+        "--proxy",
+        help="Proxy URL (e.g. socks5://127.0.0.1:1080)",
+        type=str,
+    )
+    parser.add_argument(
+        "--wss-link",
+        help="WSS URL(e.g. wss://sydney.bing.com/sydney/ChatHub)",
+        type=str,
+        default="wss://sydney.bing.com/sydney/ChatHub",
+    )
+    parser.add_argument(
+        "--style",
+        choices=["creative", "balanced", "precise"],
+        default="balanced",
+    )
+    parser.add_argument(
+        "--prompt",
+        type=str,
+        default="",
+        required=False,
+        help="prompt to start with",
+    )
+    parser.add_argument(
+        "--cookie-file",
+        type=str,
+        default="",
+        required=False,
+        help="path to cookie file",
+    )
+    parser.add_argument(
+        "--history-file",
+        type=str,
+        default="",
+        required=False,
+        help="path to history file",
+    )
+    parser.add_argument(
+        "--locale",
+        type=str,
+        default="en-US",
+        required=False,
+        help="your locale",
+    )
+    args = parser.parse_args()
+    asyncio.run(async_main(args))
+
+
+class Cookie:
+    """
+    Convenience class for Bing Cookie files, data, and configuration. This Class
+    is updated dynamically by the Query class to allow cycling through >1
+    cookie/credentials file e.g. when daily request limits (current 200 per
+    account per day) are exceeded.
+    """
+
+    current_file_index = 0
+    dirpath = Path("./").resolve()
+    search_pattern = "bing_cookies_*.json"
+    ignore_files = set()
+    current_filepath: dict | None = None
+
+    @classmethod
+    def fetch_default(cls, path=None):
+        from selenium import webdriver
+        from selenium.webdriver.common.by import By
+
+        driver = webdriver.Edge()
+        driver.get("https://bing.com/chat")
+        time.sleep(5)
+        xpath = '//button[@id="bnp_btn_accept"]'
+        driver.find_element(By.XPATH, xpath).click()
+        time.sleep(2)
+        xpath = '//a[@id="codexPrimaryButton"]'
+        driver.find_element(By.XPATH, xpath).click()
+        if path is None:
+            path = Path("./bing_cookies__default.json")
+            # Double underscore ensures this file is first when sorted
+        cookies = driver.get_cookies()
+        Path(path).write_text(json.dumps(cookies, indent=4), encoding="utf-8")
+        # Path again in case supplied path is: str
+        print(f"Cookies saved to: {path}")
+        driver.quit()
+
+    @classmethod
+    def files(cls):
+        """Return a sorted list of all cookie files matching .search_pattern"""
+        all_files = set(cls.dirpath.glob(cls.search_pattern))
+        return sorted(list(all_files - cls.ignore_files))
+
+    @classmethod
+    def import_data(cls):
+        """
+        Read the active cookie file and populate the following attributes:
+
+          .current_filepath
+          .current_data
+          .image_token
+        """
+        try:
+            cls.current_filepath = cls.files()[cls.current_file_index]
+        except IndexError as exc:
+            print(
+                "> Please set Cookie.current_filepath to a valid cookie file, then run Cookie.import_data()",
+            )
+            raise "No valid cookie file found." from exc
+        print(f"> Importing cookies from: {cls.current_filepath.name}")
+        with open(cls.current_filepath, encoding="utf-8") as file:
+            cls.current_data = json.load(file)
+        cls.image_token = [x for x in cls.current_data if x.get("name") == "_U"]
+        cls.image_token = cls.image_token[0].get("value")
+
+    @classmethod
+    def import_next(cls):
+        """
+        Cycle through to the next cookies file.  Import it.  Mark the previous
+        file to be ignored for the remainder of the current session.
+        """
+        cls.ignore_files.add(cls.current_filepath)
+        if Cookie.current_file_index >= len(cls.files()):
+            Cookie.current_file_index = 0
+        Cookie.import_data()
+
+
+class Query:
+    """
+    A convenience class that wraps around EdgeGPT.Chatbot to encapsulate input,
+    config, and output all together.  Relies on Cookie class for authentication
+    """
+
+    def __init__(
+        self,
+        prompt,
+        style="precise",
+        content_type="text",
+        cookie_file=0,
+        echo=True,
+        echo_prompt=False,
+        proxy: str | None = None,
+    ):
+        """
+        Arguments:
+
+        prompt: Text to enter into Bing Chat
+        style: creative, balanced, or precise
+        content_type: "text" for Bing Chat; "image" for Dall-e
+        cookie_file: Path, filepath string, or index (int) to list of cookie paths
+        echo: Print something to confirm request made
+        echo_prompt: Print confirmation of the evaluated prompt
+        """
+        self.proxy = proxy
+        self.index = []
+        self.request_count = {}
+        self.image_dirpath = Path("./").resolve()
+        Cookie.import_data()
+        self.index += [self]
+        self.prompt = prompt
+        files = Cookie.files()
+        if isinstance(cookie_file, int):
+            index = cookie_file if cookie_file < len(files) else 0
+        else:
+            if not isinstance(cookie_file, (str, Path)):
+                message = "'cookie_file' must be an int, str, or Path object"
+                raise TypeError(message)
+            cookie_file = Path(cookie_file)
+            if cookie_file in files:  # Supplied filepath IS in Cookie.dirpath
+                index = files.index(cookie_file)
+            else:  # Supplied filepath is NOT in Cookie.dirpath
+                if cookie_file.is_file():
+                    Cookie.dirpath = cookie_file.parent.resolve()
+                if cookie_file.is_dir():
+                    Cookie.dirpath = cookie_file.resolve()
+                index = 0
+        Cookie.current_file_index = index
+        if content_type == "text":
+            self.style = style
+            self.log_and_send_query(echo, echo_prompt)
+        if content_type == "image":
+            self.create_image()
+
+    def log_and_send_query(self, echo, echo_prompt):
+        self.response = asyncio.run(self.send_to_bing(echo, echo_prompt))
+        name = str(Cookie.current_filepath.name)
+        if not self.request_count.get(name):
+            self.request_count[name] = 1
+        else:
+            self.request_count[name] += 1
+
+    def create_image(self):
+        image_generator = ImageGen(Cookie.image_token)
+        image_generator.save_images(
+            image_generator.get_images(self.prompt),
+            output_dir=self.image_dirpath,
+        )
+
+    async def send_to_bing(self, echo=True, echo_prompt=False):
+        """Creat, submit, then close a Chatbot instance.  Return the response"""
+        retries = len(Cookie.files())
+        while retries:
+            try:
+                # Read the cookies file
+                bot = await Chatbot.create(
+                    proxy=self.proxy, cookies=Cookie.current_data
+                )
+                if echo_prompt:
+                    print(f"> {self.prompt}=")
+                if echo:
+                    print("> Waiting for response...")
+                if self.style.lower() not in "creative balanced precise".split():
+                    self.style = "precise"
+                response = await bot.ask(
+                    prompt=self.prompt,
+                    conversation_style=getattr(ConversationStyle, self.style),
+                    # wss_link="wss://sydney.bing.com/sydney/ChatHub"
+                    # What other values can this parameter take? It seems to be optional
+                )
+                return response
+            except KeyError:
+                print(
+                    f"> KeyError [{Cookie.current_filepath.name} may have exceeded the daily limit]",
+                )
+                Cookie.import_next()
+                retries -= 1
+            finally:
+                await bot.close()
+
+    @property
+    def output(self):
+        """The response from a completed Chatbot request"""
+        return self.response["item"]["messages"][1]["text"]
+
+    @property
+    def sources(self):
+        """The source names and details parsed from a completed Chatbot request"""
+        return self.response["item"]["messages"][1]["sourceAttributions"]
+
+    @property
+    def sources_dict(self):
+        """The source names and details as a dictionary"""
+        sources_dict = {}
+        name = "providerDisplayName"
+        url = "seeMoreUrl"
+        for source in self.sources:
+            if name in source.keys() and url in source.keys():
+                sources_dict[source[name]] = source[url]
+            else:
+                continue
+        return sources_dict
+
+    @property
+    def code(self):
+        """Extract and join any snippets of Python code in the response"""
+        code_blocks = self.output.split("```")[1:-1:2]
+        code_blocks = ["\n".join(x.splitlines()[1:]) for x in code_blocks]
+        return "\n\n".join(code_blocks)
+
+    @property
+    def languages(self):
+        """Extract all programming languages given in code blocks"""
+        code_blocks = self.output.split("```")[1:-1:2]
+        return {x.splitlines()[0] for x in code_blocks}
+
+    @property
+    def suggestions(self):
+        """Follow-on questions suggested by the Chatbot"""
+        return [
+            x["text"]
+            for x in self.response["item"]["messages"][1]["suggestedResponses"]
+        ]
+
+    def __repr__(self):
+        return f"<EdgeGPT.Query: {self.prompt}>"
+
+    def __str__(self):
+        return self.output
+
+
+class ImageQuery(Query):
+    def __init__(self, prompt, **kwargs):
+        kwargs.update({"content_type": "image"})
+        super().__init__(prompt, **kwargs)
+
+    def __repr__(self):
+        return f"<EdgeGPT.ImageQuery: {self.prompt}>"
+
+
+if __name__ == "__main__":
+    main()

README.md

@@ -1,12 +1,13 @@
 ---
-title: New Bing Chat ENGLISH
-emoji: 💻
-colorFrom: gray
-colorTo: yellow
-sdk: streamlit
-sdk_version: 1.21.0
+title: New-Bing-Chat-ENGLISH
+emoji: 🐨
+colorFrom: red
+colorTo: gray
+sdk: gradio
+sdk_version: 3.23.0
 app_file: app.py
-pinned: false
+pinned: true
+license: other
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,46 @@
+import streamlit as st
+import json
+import asyncio
+import os
+import EdgeGPT
+from EdgeGPT import Chatbot, ConversationStyle
+import re
+
+async def get_model_reply(prompt, style, cookies, context=[]):
+    context = [prompt]
+    cookies = json.loads(cookies)
+
+    # Rest of the code...
+
+# UI code using Streamlit
+def main():
+    st.title("New Bing Chat GPT4")
+
+    st.markdown("""
+    - If the response is "1", it means the service is busy. We recommend trying again later.
+    - If the response is "0", please refresh the page and try again.
+    - If the response is "-1", the account needs to be reactivated using a proxy server.
+    - If the response is "-2", the account requires human verification on the Bing chat page.
+    
+    **Note:** The code has been updated to return the desired format when [choices = None] is passed, which means no specific choices mode is selected.
+    """)
+
+    inputs = st.text_input("Enter your question", "Hello")
+    style = st.selectbox("Response Style", ["creative", "balanced", "precise"])
+
+    # Load cookies from JSON file
+    with open('./cookies.json', 'r') as f:
+        cookies = json.load(f)
+
+    if st.button("Send Request"):
+        state = []
+        responses, state = asyncio.run(get_model_reply(inputs, style, json.dumps(cookies), state))
+
+        if len(responses) > 0:
+            for user, bot in responses:
+                st.text("User: " + user)
+                st.text("Bot: " + bot)
+                st.markdown("---")
+
+if __name__ == "__main__":
+    main()

cookies.json

@@ -0,0 +1,364 @@
+can you help me understand line by line how this bing AI chatbot's cookies work and how they can be used to create python code to use it effectively  as a chatbot
+
+
+\[
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1719057020.716042,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "SnrOvr",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "X=rebateson"
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1721994605.964768,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "SRCHUSR",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "DOB=20230622&T=1687434589000&POEX=W"
+    },
+    {
+        "domain": "www.bing.com",
+        "expirationDate": 1687436423,
+        "hostOnly": true,
+        "httpOnly": false,
+        "name": "ai_session",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "RF1p1mBDe7wTRTseF6Iz+G|1687434592931|1687434623279"
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1687477817.199317,
+        "hostOnly": false,
+        "httpOnly": true,
+        "name": "SUID",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "A"
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1721994620.575677,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "SRCHHPGUSR",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "SRCHLANG=en&PV=15.0.0&BRW=S&BRH=S&CW=1067&CH=699&SCW=1067&SCH=699&DPR=1.5&UTC=-300&DM=1&HV=1687434621&WTS=63823031389&PRVCW=1067&PRVCH=699"
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1703245816.640784,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "ANON",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "A=B7E892EEC685402345AFB183FFFFFFFF&E=1c7c&W=1"
+    },
+    {
+        "domain": "www.bing.com",
+        "expirationDate": 1718970623.060166,
+        "hostOnly": true,
+        "httpOnly": false,
+        "name": "MicrosoftApplicationsTelemetryDeviceId",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "5368eb97-91b2-4a77-a889-5134e8a32352"
+    },
+    {
+        "domain": ".bing.com",
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "_SS",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": true,
+        "storeId": null,
+        "value": "SID=0ACF7BCA173B6ED7179F68F216546F09&R=5130&RB=5130&GB=0&RG=6500&RP=0"
+    },
+    {
+        "domain": ".bing.com",
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "ipv6",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": true,
+        "storeId": null,
+        "value": "hit=1687438193778&t=4"
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1688644216.640939,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "_U",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "1sNNlfydW4RjdHkyYqPUG5uPzkvgDSeAmTaeSXs2dXEiqwj1_enafZrbr2G8ca9eSqMPwlNPlTATxSTkkodcii-byULcU7DJ4z45LogCFI9wOwbARwKh_1R-aSJjKHgmgZgbh-66zBybnmH5cNv8flqzxbBKfcPOGhTelwsLXBRToen6oJXni7Re61EEqr1EwSzYpiffyR7iEhK6m849sB1tkaZLHMj4X44kmMrfTuhY"
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1721977968.730789,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "SRCHD",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "AF=NOFORM"
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1721994616.640824,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "PPLState",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "1"
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1718970621,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "amp_e5f096_bing.com",
+        "path": "/",
+        "sameSite": "lax",
+        "secure": false,
+        "session": false,
+        "storeId": null,
+        "value": "0sC_P96Kqk9Ek6aa_qrfma...1h3hf0tsi.1h3hf1s6v.0.0.0"
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1721113969.730779,
+        "hostOnly": false,
+        "httpOnly": true,
+        "name": "_EDGE_V",
+        "path": "/",
+        "sameSite": null,
+        "secure": false,
+        "session": false,
+        "storeId": null,
+        "value": "1"
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1704743416.640806,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "NAP",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "V=1.9&E=1c22&C=r7Tz0M2KvloiF0KxUIWf3W1RrAggGI6c3nFHVZKwHZ-rJ6GjWzYDxA&W=1"
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1721994620.965844,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "_RwBf",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "ilt=1&ihpd=1&ispd=0&rc=5130&rb=5130&gb=0&rg=6500&pc=0&mtu=0&rbb=0.0&g=0&cid=&clo=0&v=2&l=2023-06-22T07:00:00.0000000Z&lft=0001-01-01T00:00:00.0000000&aof=0&o=16&p=sapphire&c=true&t=6853&s=2023-03-03T18:14:35.9462777+00:00&ts=2023-06-22T11:50:20.9783807+00:00&rwred=0&wls=2&lka=0&lkt=0&TH=&dci=0&r=1&mta=0&e=Lq7CR08AZViOwp0DA2GFsGwJR_yyiHE3vmd6GVsWez-gSWBqaGgwuwOd-KbCVfdJTG0DOYPvU9GfhdtXSBnDSQyOY1H4-eqWU_mbyYVEODY&A=B7E892EEC685402345AFB183FFFFFFFF"
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1721994626.04557,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "_UR",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "QS=0&TQS=0"
+    },
+    {
+        "domain": ".bing.com",
+        "hostOnly": false,
+        "httpOnly": true,
+        "name": "_EDGE_S",
+        "path": "/",
+        "sameSite": null,
+        "secure": false,
+        "session": true,
+        "storeId": null,
+        "value": "SID=1A3C463F2C7060292A3755072D1F61DE"
+    },
+    {
+        "domain": ".bing.com",
+        "hostOnly": false,
+        "httpOnly": true,
+        "name": "CSRFCookie",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": true,
+        "storeId": null,
+        "value": "1fe5f6f7-0958-4b3f-8afc-1595ba6044a0"
+    },
+    {
+        "domain": "www.bing.com",
+        "expirationDate": 1721130625.938491,
+        "hostOnly": true,
+        "httpOnly": true,
+        "name": "MUIDB",
+        "path": "/",
+        "sameSite": null,
+        "secure": false,
+        "session": false,
+        "storeId": null,
+        "value": "3D68C9DDD3BD69290CEFDAE5D2D268C8"
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1721994589.285074,
+        "hostOnly": false,
+        "httpOnly": true,
+        "name": "USRLOC",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "HS=1"
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1721994626.04604,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "_HPVN",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "CS=eyJQbiI6eyJDbiI6MSwiU3QiOjAsIlFzIjowLCJQcm9kIjoiUCJ9LCJTYyI6eyJDbiI6MSwiU3QiOjAsIlFzIjowLCJQcm9kIjoiSCJ9LCJReiI6eyJDbiI6MSwiU3QiOjAsIlFzIjowLCJQcm9kIjoiVCJ9LCJBcCI6dHJ1ZSwiTXV0ZSI6dHJ1ZSwiTGFkIjoiMjAyMy0wNi0yMlQwMDowMDowMFoiLCJJb3RkIjowLCJHd2IiOjAsIkRmdCI6bnVsbCwiTXZzIjowLCJGbHQiOjAsIkltcCI6M30="
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1718970621,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "amp_e5f096",
+        "path": "/",
+        "sameSite": "lax",
+        "secure": false,
+        "session": false,
+        "storeId": null,
+        "value": "0sC_P96Kqk9Ek6aa_qrfma...1h3hf0tsi.1h3hf1s5c.0.0.0"
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1721994616.640842,
+        "hostOnly": false,
+        "httpOnly": true,
+        "name": "KievRPSSecAuth",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "FACCBBRaTOJILtFsMkpLVWSG6AN6C/svRwNmAAAEgAAACEQlbg+c+ErCQAQZWRhVAYNGFThpR0iVu5I07ZggVc5dYjPEYkTk0rNO5ooUOn8ayXD6cpcrxEm2JF2jp/Norc8n59KOaQbt54QSDdPxWYxcqX4iGdI/TEX8YWwpKErspCmZITrunIbU1OCwEzgPL0l6CIP+QyJ5b58IDIRJAeJ6hb+ZH66sT6Jhos8x7KcnlCNnlP5kyQuta6/u98xzWHXbSsStGCmTSVfLkAif8mUC8kS1p8/E69mMJbKs9alssXkgQowoXkE9LvKdcrie9tmGG5OzGWSDFEH+bk8ILhcWncYet16bdMy1ChHjxdaEnM3a7HKV0BJ98DOlxKXww/Mw2cBmSlJjZqkH9jL0ZcgImCMrdDUsIDgIsiHO2C8GyDlL3IWZYTA3NhOL49vjE6+EnTlsV2lmBPLepbw+oL7LLRjxSt1xZIFMaDXPx0AEYdmD23x18w3VwR5EoIqBV6XZBynm594n77MYBVnDvbpyT4is4jIo1wzsWs7jApmDL0IJGfehS/E6HmbJGKOgzcP3AteI+zepVdhX+Y8kuJI8ObhaZB9Fy/xuEiqcIiRKXS7NF5E6nFxC/HxASUqrXIp5sDP9qEE37aFAZCDqETwjDpaBQLT4kWP2uaIM4kYbxNKC2A8qcr6AfqTyJvJNT9BphcFZ6hvClM9OFovO5NGGFADwIY3huDLrkhTomZHTbLBVbhRREoqB9eGLbowRJv0NnoaRSLayVxHXMhHCfI0YacCBO/4wGeCA8CH3kSp9fbedydtOG1QqqI2pLeTCgN4gG0bfzM6/JzOHNxl8mo4y48vvdUMvNU0tlaIOIPLEOhYM26YNdO+8VDgv8+SKALK37JNS6vJUSdu/F9rOklSZdouqalCMWMm8Np6PzYN43krmMa4lcrPDmSrseLcK7OJlLFLoQCuDDJKpDoveXGHUpyRbp+IugJcghyomtc9TAvRO9QxJK75xrAsOYKwBrrn4NEFQ8mrxoM/sBfVoMpycmsUZF1zKO/2ps5QVl+ACDYP5BkEWKPNheNKtF37hdgqsxGuw55zq6AtJh3oOgJPoqrF+EsfSGPMWIiiagROcu5Hd6toPvQ2IVsuB8N3bMVnL582aORFaGTtZpi8Y3LhrbF/qBmdQk0NnC6bot40jjMoMZyDVTrd2oXBnSoUOcq5KYdjoXz/5I8wT3wX/9gepi40KBPgia7wg3t91UUtXXXWCJ4+lXphxW9XBtXEW+XnFza9UnQwNifUHIzlF7TMWpOIy2hUEnrTdSQiq7+7ULXegl+u/WPcdWT/+WU2KgVN7qEKel/U9s+5c8oNArTTWDLbv5OoSBgGKioUnKjn7LXYmRMLUd1Nr7+g0reg8u8s3X53h1O7Z6MJ9MyZYHMekpWLZ8SmWA9Pkb2jpGjZjYhBvJthasBgO1GMiME8i3zGJrdJkyD7YV/UhmMjguxoTjWr1rtRFjB+BQRQAtTToVfUNsbaXYzInyoTg/cZTnWQ="
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1721122200.962837,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "MUID",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "3D68C9DDD3BD69290CEFDAE5D2D268C8"
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1721977968.730799,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "SRCHUID",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "V=2&GUID=D57ED6E662FA4C12ABB4174A433C210E&dmnchg=1"
+    },
+    {
+        "domain": ".bing.com",
+        "expirationDate": 1688644217.199239,
+        "hostOnly": false,
+        "httpOnly": true,
+        "name": "WLID",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "VJvwhcbha0XjSWPmoRbUNDvglkf/V3Zi7Zft1ahMWA5Ef1XjikFzakW2fWcpb+ZtTy4BW9dgjX4JhCT7z5M+/L8Tu6LwHP0mG8AGlKZPJkg="
+    },
+    {
+        "domain": ".bing.com",
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "WLS",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": true,
+        "storeId": null,
+        "value": "C=2f1564bfa10412ba&N=grim"
+    }
+]

gitattributes.txt

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

requirements.txt

@@ -0,0 +1,13 @@
+gradio
+requests
+rich
+websockets
+aiohttp
+BingImageCreator
+certifi
+httpx
+prompt_toolkit
+requests
+rich
+
+