cruds are ready

.gitignore

@@ -1,130 +0,0 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-pip-wheel-metadata/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-.python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-cookies.json

.pre-commit-config.yaml

@@ -1,31 +0,0 @@
-repos:
-  - repo: https://github.com/asottile/reorder_python_imports
-    rev: v3.9.0
-    hooks:
-      - id: reorder-python-imports
-        args: [--py37-plus]
-  - repo: https://github.com/asottile/add-trailing-comma
-    rev: v2.3.0
-    hooks:
-      - id: add-trailing-comma
-        args: [--py36-plus]
-  - repo: https://github.com/asottile/pyupgrade
-    rev: v3.3.1
-    hooks:
-      - id: pyupgrade
-        args: [--py37-plus]
-
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
-    hooks:
-      - id: trailing-whitespace
-      - id: end-of-file-fixer
-      - id: check-yaml
-      - id: debug-statements
-      - id: double-quote-string-fixer
-      - id: name-tests-test
-      - id: requirements-txt-fixer
-  - repo: https://github.com/psf/black
-    rev: 22.10.0
-    hooks:
-      - id: black

App/Analytics/AnalyticsRoutes.py

@@ -0,0 +1,10 @@
+from fastapi import APIRouter, status
+from .Schemas import BaseRequest, editRequest
+from .Model import Comments
+from App.Users.Model import User
+from App.Post.Model import Post
+
+analytics_router = APIRouter(tags=["Analytics"])
+
+
+

App/Analytics/Model.py

@@ -0,0 +1,21 @@
+import asyncio
+import orm
+import psycopg2
+import datetime
+import pydantic
+from App.modelInit import database, models
+from App.Users.Model import User
+
+
+class Analytics(orm.Model):
+    tablename = "Analytics"
+    registry = models
+    fields = {
+        "id": orm.Integer(primary_key=True),
+        "user": orm.ForeignKey(User, on_delete=orm.CASCADE,allow_null=True),  # Optional for unknown users.
+        "post": orm.ForeignKey(User, on_delete=orm.CASCADE),
+        "ip": orm.String(max_length=100),
+        "device": orm.String(max_length=100),
+        "country": orm.String(max_length=100),        
+        "createdAt": orm.DateTime(index=True, default=datetime.datetime.now),
+    }

App/Analytics/Schemas.py

@@ -0,0 +1,15 @@
+from typing import List, Optional
+from pydantic import EmailStr, BaseModel
+from datetime import date, datetime, time, timedelta
+
+
+class BaseRequest(BaseModel):
+    user: Optional[int]
+    id: Optional[int]
+    content: Optional[str]
+
+
+class editRequest(BaseRequest):
+    updatedAt: datetime = datetime.now()
+
+    

App/Authentication.py

@@ -0,0 +1,7 @@
+from fastapi import APIRouter, status
+from fastapi.security import OAuth2PasswordBearer,OAuth2PasswordRequestForm 
+
+
+
+
+

App/CommentLikes/CommentLikesRoutes.py

@@ -0,0 +1,11 @@
+from fastapi import APIRouter, status
+from .Schemas import BaseRequest, editRequest
+from .Model import Comments
+from App.Users.Model import User
+from App.Post.Model import Post
+
+commentLikes_router = APIRouter(tags=["CommentLikes"])
+
+@commentLikes_router.get('/likes/comments/add')
+async def add_commentLike():
+    pass

App/CommentLikes/Model.py

@@ -0,0 +1,18 @@
+import asyncio
+import orm
+import psycopg2
+import datetime
+import pydantic
+from App.modelInit import database, models
+from App.Users.Model import User
+from App.Post.Model import Post
+
+class CommentLike(orm.Model):
+    tablename = "commentlikes"
+    registry = models
+    fields = {
+        "id": orm.Integer(primary_key=True),
+        "user": orm.ForeignKey(User, on_delete=orm.CASCADE),
+        "post": orm.ForeignKey(Post, on_delete=orm.CASCADE),
+        "createdAt": orm.DateTime(index=True, default=datetime.datetime.now),
+    }

App/CommentLikes/Schemas.py

@@ -0,0 +1,15 @@
+from typing import List, Optional
+from pydantic import EmailStr, BaseModel
+from datetime import date, datetime, time, timedelta
+
+
+class addLike (BaseModel):
+    postId:int
+    userId:int
+
+class deleteLike (BaseModel):
+    id:int
+    postId:int
+    userId:int
+
+    

App/Comments/CommentRoutes.py

@@ -0,0 +1,53 @@
+from fastapi import APIRouter, status
+from .Schemas import createComment,editComment,deleteComment,allComments
+from .Model import Comment
+from App.Users.Model import User
+from App.Post.Model import Post
+from App.utils import get_user_and_post
+import asyncio
+postLike_router = APIRouter(tags=["PostLikes"])
+
+
+
+
+comment_router = APIRouter(tags=["Comments"])
+
+
+@comment_router.post("/comment/create")
+async def create_comment(comment: createComment):
+    user,_post = await get_user_and_post(comment)
+    db_data = await Comment.objects.create(user=user, content=comment.content,post=_post)
+    return {"code": 200, "message": "success", "payload": data.__dict__}
+
+
+@comment_router.post("/comment/edit")
+async def edit_comment(comment: editComment):
+    # user,_post = await get_user_and_post(comment)
+    db_comment = await Comment.objects.filter(id=comment.id).first()
+    if not db_comment:
+        return {"code": 400, "message": "Comment does not exist", "payload": None}
+    if db_comment.user.id != comment.userId:
+        return {
+            "code": 400,
+            "message": "This comment belongs to a different user",
+            "payload": None,
+        }
+    db_data = await db_comment.update(content=comment.content)
+    return {"code": 200, "message": "success", "payload": None}
+
+
+@comment_router.post("/comment/all")
+async def all_comments(comment: allComments):
+
+    user = await User.objects.filter(id=comment.userId).first()
+    if not user:
+        return {"code": 400, "message": "User does not exist", "payload": None}
+    db_comment = await Comment.objects.filter(user=user).all()
+
+    if not db_comment:
+        return {"code": 400, "message": "Comment does not exist", "payload": None}
+    return {
+        "code": 200,
+        "message": "success",
+        "payload": [i.__dict__ for i in db_comment],
+    }

App/Comments/Model.py

@@ -0,0 +1,21 @@
+import asyncio
+import orm
+import psycopg2
+import datetime
+import pydantic
+from App.modelInit import database, models
+from App.Users.Model import User
+
+
+class Comment(orm.Model):
+    tablename = "comments"
+    registry = models
+    fields = {
+        "id": orm.Integer(primary_key=True),
+        "user": orm.ForeignKey(User, on_delete=orm.CASCADE),
+        "post": orm.ForeignKey(User, on_delete=orm.CASCADE),
+        "content": orm.String(max_length=100),
+        "likes": orm.Integer(index=True, default=0),
+        "createdAt": orm.DateTime(index=True, default=datetime.datetime.now),
+        "updatedAt": orm.DateTime(index=True, default=datetime.datetime.now),
+    }

App/Comments/Schemas.py

@@ -0,0 +1,24 @@
+from typing import List, Optional
+from pydantic import EmailStr, BaseModel
+from datetime import date, datetime, time, timedelta
+
+
+class createComment(BaseModel):
+    userId: int
+    content: str
+    postId:int
+
+
+class editComment(BaseModel):
+    id:int
+    userId: int
+    content: str
+    postId:int
+
+class deleteComment(BaseModel):
+    id:int
+    userId: int
+    postId:int
+
+class allComments(BaseModel):
+    userId: int

App/Post/Model.py

@@ -0,0 +1,19 @@
+import asyncio
+import orm
+import psycopg2
+import datetime
+import pydantic
+from App.modelInit import database, models
+from App.Users.Model import User
+
+
+class Post(orm.Model):
+    tablename = "posts"
+    registry = models
+    fields = {
+        "id": orm.Integer(primary_key=True),
+        "pageId": orm.Integer(index=True,default=0),
+        "content": orm.JSON(),
+        "recommendations": orm.JSON(allow_null=True),
+        "createdAt": orm.DateTime(index=True, default=datetime.datetime.now),
+    }

App/Post/PostRoutes.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter, status
+from .Schemas import createPost,editPost,getPost
+from .Model import Post
+
+post_router = APIRouter(tags=["Posts"])
+
+
+@post_router.post("/post/create")
+async def create_post(post: createPost):
+    data=await Post.objects.create(**post.dict())
+    return {"code": 200, "message": "success", "payload": data.__dict__}
+
+@post_router.post("/post/update")
+async def create_post(post: editPost):
+    temp=await Post.objects.get(id= post.id)
+    data=await temp.update(recommendations=post.recommendations,content=post.content)
+    # data=await Post.objects.update(**post.dict())
+    return {"code": 200, "message": "success", "payload": temp.__dict__}
+
+
+@post_router.post("/post/get")
+async def create_post(post: getPost):
+    data=await Post.objects.get(id=post.id)
+    return {"code": 200, "message": "success", "payload": data.__dict__}

App/Post/Schemas.py

@@ -0,0 +1,19 @@
+from typing import List, Optional
+from pydantic import EmailStr, BaseModel
+from datetime import date, datetime, time, timedelta
+
+
+class editPost(BaseModel):
+    id: Optional[int]
+    content:Optional[dict]
+    recommendations:Optional[dict]
+
+
+class createPost(BaseModel):
+    content:Optional[dict]
+    recommendations:Optional[dict]
+
+class getPost(BaseModel):
+    id: Optional[int]
+
+    

App/PostLikes/Model.py

@@ -0,0 +1,20 @@
+import asyncio
+import orm
+import psycopg2
+import datetime
+import pydantic
+from App.modelInit import database, models
+from App.Users.Model import User
+from App.Post.Model import Post
+
+
+class PostLike(orm.Model):
+    tablename = "postlikes"
+    registry = models
+    fields = {
+        "id": orm.Integer(primary_key=True),
+        "user": orm.ForeignKey(User, on_delete=orm.CASCADE),
+        "post": orm.ForeignKey(Post, on_delete=orm.CASCADE),
+        "createdAt": orm.DateTime(index=True, default=datetime.datetime.now)
+    }
+

App/PostLikes/PostLikesRoutes.py

@@ -0,0 +1,41 @@
+from fastapi import APIRouter, Depends
+from .Schemas import addLike,deleteLike
+from .Model import PostLike
+from App.Users.Model import User
+from App.Post.Model import Post
+from App.utils import get_user_and_post
+import asyncio
+postLike_router = APIRouter(tags=["PostLikes"])
+
+
+
+
+@postLike_router.post("/postLike/add")
+async def add_postLike(post: addLike):
+    user,_post=await get_user_and_post(post) #validate if both the post and user exist
+    previos =await PostLike.objects.filter(user=user).filter(post=_post).first()
+    if previos:
+        return {"code": 400, "message": "you already liked it", "payload": None}
+    
+    data=await PostLike.objects.create(post=_post,user=user)
+    return {"code": 200, "message": "success", "payload": data.__dict__}
+
+@postLike_router.post("/postLike/delete")
+async def create_post(post: deleteLike):
+    user,_post=await get_user_and_post(post)
+    data=await PostLike.objects.filter(id=post.id).first()
+    if not data:
+        return {"code": 400, "message": "Does not exist", "payload": None}
+    if user.id == data.user.id and _post.id == data.post.id:
+        await data.delete()
+        return {"code": 200, "message": "success", "payload": None}
+
+
+@postLike_router.post("/postLike/get")
+async def create_post(post: deleteLike):
+    user,_post=await get_user_and_post(post)
+    data=await PostLike.objects.filter(id=post.id).first()
+    if not data:
+        return {"code": 400, "message": "Does not exist", "payload": None}
+    if user.id == data.user.id and _post.id == data.post.user.id:
+        return {"code": 200, "message": "success", "payload": data.__dict__}

App/PostLikes/Schemas.py

@@ -0,0 +1,16 @@
+from typing import List, Optional
+from pydantic import EmailStr, BaseModel
+from datetime import date, datetime, time, timedelta
+
+
+class addLike (BaseModel):
+    postId:int
+    userId:int
+
+class deleteLike (BaseModel):
+    id:int
+    postId:int
+    userId:int
+
+
+    

App/Settings.py

@@ -0,0 +1,3 @@
+class Settings:
+    ALGORITHM = "HS256"
+    HASH="86c5ceb27e1bf441130299c0209e5f35b88089f62c06b2b09d65772274f12057"

App/Users/Model.py

@@ -0,0 +1,28 @@
+import asyncio
+import orm
+import psycopg2
+import datetime
+import pydantic
+from passlib.context import CryptContext
+from App.modelInit import database, models
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+
+class User(orm.Model):
+    tablename = "users"
+    registry = models
+    fields = {
+        "id": orm.Integer(primary_key=True),
+        "name": orm.String(max_length=100, index=True),
+        "email": orm.String(max_length=100, index=True, unique=True),
+        "password": orm.String(max_length=100, index=True),
+        "phoneNumber": orm.String(max_length=100, index=True, allow_null=True),
+        "account_type": orm.Integer(index=True, default=1),
+        "createdAt": orm.DateTime(index=True, default=datetime.datetime.now),
+        "updatedAt": orm.DateTime(index=True, default=datetime.datetime.now),
+        "lastLogin": orm.DateTime(index=True, default=datetime.datetime.now),
+    }
+
+    def verify_password(self, plain_password):
+        return pwd_context.verify(plain_password, self.password)

App/Users/Schemas.py

@@ -0,0 +1,15 @@
+from typing import List, Optional
+from pydantic import EmailStr, BaseModel
+from passlib.context import CryptContext
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+
+class BaseRequest(BaseModel):
+    email: EmailStr
+    name: str
+    password: str
+    phoneNumber: Optional[str]
+
+    def hash_password(self):
+        self.password = pwd_context.hash(self.password)

App/Users/UserRoutes.py

@@ -0,0 +1,27 @@
+from fastapi import APIRouter, status
+from .Schemas import BaseRequest
+from .Model import User
+from sqlalchemy import and_
+from fastapi.security import OAuth2PasswordBearer,OAuth2PasswordRequestForm 
+
+oauth_scheme=OAuth2PasswordBearer(tokenUrl='/user/login')
+user_router = APIRouter(tags=["User"])
+
+
+@user_router.post("/user/register")
+async def register_user(user: BaseRequest):
+    data = await User.objects.filter(email=user.email).first()
+    if data != None:
+        return {"code": 400, "message": "user exists", "payload": None}
+    else:
+        user.hash_password()
+    sample = await User.objects.create(**user.dict())
+    return {"code": 200, "message": "success", "payload": None}
+
+
+@user_router.post("/user/login")
+async def register_user(user: BaseRequest):
+    db_user = await User.objects.filter(email=user.email).first()
+    if db_user.verify_password(user.password):
+        return {"code": 200, "message": "success", "payload": db_user.__dict__}
+    return {"code": 401, "message": "Invalid Credentials", "payload": None}

App/app.py

@@ -0,0 +1,36 @@
+from fastapi import FastAPI
+from .Users.UserRoutes import user_router
+from .Post.PostRoutes import post_router
+from .PostLikes.PostLikesRoutes import postLike_router
+from .Comments.CommentRoutes import comment_router
+from .modelInit import models, database
+
+app = FastAPI()
+
+
+@app.on_event("startup")
+async def startup_event():
+    await models.create_all()
+    if not database.is_connected:
+        await database.connect()
+        print("connected!")
+
+
+@app.get("/")
+async def landing_page():
+    return {"code": 200, "message": "still running"}
+
+
+app.include_router(user_router)
+app.include_router(comment_router)
+app.include_router(post_router)
+app.include_router(postLike_router)
+
+
+async def main():
+    pass
+
+
+# if __name__ == "__main__":
+#     main()
+#     uvicorn.run(app, host="0.0.0.0", port=8000)

App/modelInit.py

@@ -0,0 +1,9 @@
+import databases
+import orm
+import psycopg2
+
+database = databases.Database(
+    "postgresql+asyncpg://postgres:[email protected]:5432/postgres"
+)
+# databases = databases.Database(**args)
+models = orm.ModelRegistry(database=database)

App/utils.py

@@ -0,0 +1,14 @@
+from App.Users.Model import User
+from App.Post.Model import Post
+import asyncio
+from fastapi import HTTPException
+
+async def get_user_and_post(content):
+    try:
+    #    user = None
+    #    post = await Post.objects.get(id=content.postId)
+    #    print(post.id)
+        user,post = await asyncio.gather(*[User.objects.get(id=content.userId), Post.objects.get(id=content.postId)])
+    except:
+        raise HTTPException(status_code=400, detail="Invalid data")
+    return user,post

LICENSE

@@ -1,24 +0,0 @@
-This is free and unencumbered software released into the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or
-distribute this software, either in source code form or as a compiled
-binary, for any purpose, commercial or non-commercial, and by any
-means.
-
-In jurisdictions that recognize copyright laws, the author or authors
-of this software dedicate any and all copyright interest in the
-software to the public domain. We make this dedication for the benefit
-of the public at large and to the detriment of our heirs and
-successors. We intend this dedication to be an overt act of
-relinquishment in perpetuity of all present and future rights to this
-software under copyright law.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
-OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-
-For more information, please refer to <https://unlicense.org>

README.md

@@ -1,156 +0,0 @@
-<div align="center">
-  <img src="https://socialify.git.ci/acheong08/EdgeGPT/image?font=Inter&language=1&logo=https%3A%2F%2Fupload.wikimedia.org%2Fwikipedia%2Fcommons%2F9%2F9c%2FBing_Fluent_Logo.svg&owner=1&pattern=Floating%20Cogs&theme=Auto" alt="EdgeGPT" width="640" height="320" />
-
-  # Edge GPT
-
-  *The reverse engineering the chat feature of the new version of Bing*
-
-</div>
-
-<p align="center">
-  <a href="https://github.com/acheong08/EdgeGPT">
-    <img alt="PyPI version" src="https://img.shields.io/pypi/v/EdgeGPT">
-  </a>
-  <img alt="Python version" src="https://img.shields.io/badge/python-3.8+-blue.svg">
-</p>
-
----
-
-## Table of Contents
-- [Edge GPT](#edge-gpt)
-  - [Table of Contents](#table-of-contents)
-  - [Setup](#setup)
-    - [Install package](#install-package)
-    - [Requirements](#requirements)
-    - [Checking access (Required)](#checking-access-required)
-    - [Getting authentication (Required)](#getting-authentication-required)
-  - [Usage](#usage)
-    - [Quick start](#quick-start)
-    - [Developer demo](#developer-demo)
-  - [Work in progress](#work-in-progress)
-  - [Star History](#star-history)
-  - [Contributors](#contributors)
-
-## Setup
-
-### Install package
-```bash
-python3 -m pip install EdgeGPT --upgrade
-```
-
-### Requirements
-- python 3.8+
-- A Microsoft Account with early access to http://bing.com/chat (Required)
-
-
-<details>
-  <summary>
-
-  ### Checking access (Required)
-
-  </summary>
-
-- Install the latest version of Microsoft Edge
-- Open http://bing.com/chat
-- If you see a chat feature, you are good to go
-
-</details>
-
-
-<details>
-  <summary>
-
-  ### Getting authentication (Required)
-
-  </summary>
-
-- Install the cookie editor extension for [Chrome](https://chrome.google.com/webstore/detail/cookie-editor/hlkenndednhfkekhgcdicdfddnkalmdm) or [Firefox](https://addons.mozilla.org/en-US/firefox/addon/cookie-editor/)
-- Go to `bing.com`
-- Open the extension
-- Click "Export" on the bottom right (This saves your cookies to clipboard)
-- Paste your cookies into a file `cookies.json`
-
-</details>
-
-
-
-## Usage
-
-### Quick start
-
-```
- $ python3 -m EdgeGPT -h
-
-        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
-        Enter twice to send message or set --enter-once to send one line message
-
-usage: EdgeGPT.py [-h] [--enter-once] [--no-stream] [--style {creative,balanced,precise}] --cookie-file COOKIE_FILE
-
-options:
-  -h, --help            show this help message and exit
-  --enter-once
-  --no-stream
-  --style {creative,balanced,precise}
-  --cookie-file COOKIE_FILE
-```
-
------
-
-### Developer demo
-
-Three ways to pass in cookies:
-
-- Environment variable: `export COOKIE_FILE=/path/to/cookies.json`.
-- Specify the path to `cookies.json` in the argument `cookiePath` like this:
-
-  ```python
-  bot = Chatbot(cookiePath='./cookie.json')
-  ```
-
-- Pass in the cookies directly by the argument `cookies`, like this:
-
-  ```python
-  with open('./cookie.json', 'r') as f:
-      cookies = json.load(f)
-  bot = Chatbot(cookies=cookies)
-  ```
-
-
-Use Async for the best experience
-
-Reference code for more advanced example of usage:
-
-```python
-import asyncio
-from EdgeGPT import Chatbot, ConversationStyle
-
-async def main():
-    bot = Chatbot()
-    print(await bot.ask(prompt="Hello world", conversation_style=ConversationStyle.creative))
-    await bot.close()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
-
-```
-
-## Work in progress
-- Error handling
-
-## Star History
-[![Star History Chart](https://api.star-history.com/svg?repos=acheong08/EdgeGPT&type=Date)](https://star-history.com/#acheong08/EdgeGPT&Date)
-
-
-## Contributors
-This project exists thanks to all the people who contribute.
-
- <a href="https://github.com/acheong08/EdgeGPT/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=acheong08/EdgeGPT" />
- </a>

data.txt

@@ -0,0 +1 @@
+

example.env

@@ -1 +0,0 @@
-export BING_U="<COOKIE_VALUE>"

requirements.txt

@@ -1,4 +1,16 @@
-asyncio
-requests
-rich
-websockets
+asyncpg==0.27.0
+click==8.1.3
+databases==0.7.0
+fastapi==0.92.0
+Flask==2.2.2
+greenlet==2.0.2
+itsdangerous==2.1.2
+orm==0.3.1
+psycopg2-binary==2.9.5
+SQLAlchemy==1.4.46
+starlette==0.25.0
+typesystem==0.3.1
+Werkzeug==2.2.2
+passlib                # for password hashing
+pydantic[email]
+python-multipart

setup.cfg

@@ -1,3 +0,0 @@
-[metadata]
-description_file=README.md
-license_files=LICENSE

setup.py

@@ -1,35 +0,0 @@
-from setuptools import find_packages
-from setuptools import setup
-
-setup(
-    name="EdgeGPT",
-    version="0.0.60",
-    license="GNU General Public License v2.0",
-    author="Antonio Cheong",
-    author_email="[email protected]",
-    description="Reverse engineered Edge Chat API",
-    packages=find_packages("src"),
-    package_dir={"": "src"},
-    url="https://github.com/acheong08/EdgeGPT",
-    project_urls={"Bug Report": "https://github.com/acheong08/EdgeGPT/issues/new"},
-    install_requires=[
-        "asyncio",
-        "httpx",
-        "websockets",
-        "rich",
-        "certifi",
-        "prompt_toolkit",
-    ],
-    long_description=open("README.md", encoding="utf-8").read(),
-    long_description_content_type="text/markdown",
-    py_modules=["EdgeGPT"],
-    classifiers=[
-        "License :: OSI Approved :: GNU General Public License v2 (GPLv2)",
-        "Intended Audience :: Developers",
-        "Topic :: Software Development :: Libraries :: Python Modules",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-        "Programming Language :: Python :: 3.10",
-        "Programming Language :: Python :: 3.11",
-    ],
-)