from fastapi import FastAPI, Request
from telegram.chatpermissions import ChatPermissions
from telegram.ext import Dispatcher, CommandHandler, CallbackContext, MessageHandler
from telegram import Update, Bot
from deta import Deta
import os
import time
from telegram.ext.filters import Filters
db = Deta(os.getenv("PROJECT_KEY")).Base("redb")
TOKEN: str = os.getenv("TOKEN")
YARBASH: str = os.getenv("BASHETTAN")
SPAM: str = os.getenv("SPAM")
def insert_to_db(usn: str) -> str:
userdata = db.get(usn)
if userdata is None:
_ = db.put({"key": usn, "re": 1})
print(_)
return "New User Added to Table"
else:
updates = {"re": userdata["re"] + 1}
db.update(updates, usn)
return "Re Count Updated"
def clean_res(message, re: bool = True) -> str:
if "@" in message:
import nltk
import os
from deta import App, Deta
from flask import Flask
from words import words
from nltk.stem import LancasterStemmer, SnowballStemmer
app = App(Flask(__name__))
sno = SnowballStemmer('english')
lan = LancasterStemmer()
proj_key = os.environ["PROJ_KEY"]
deta = Deta(proj_key)
reverse_stems = deta.Base("lancaster_stems")
def reversestemmer(word, stemmer):
variants = []
stem = stemmer.stem(word)
for each in words:
if stemmer.stem(each) == stem:
variants.append(each)
return {"key": stem, "stem": stem, "words": variants}
def formatted(stem_dict, word):
return_words = stem_dict
del return_words["key"]
from deta import App, Deta
from fastapi import FastAPI, Request, responses
from fastapi.staticfiles import StaticFiles
deta = Deta()
db = deta.Base("people") # init the DB
# We are wrapping FastAPI with a Deta wrapper to be able to use `deta run`
# See line 31. It's optional.
app = App(FastAPI())
app.mount("/static", StaticFiles(directory="static"), name="static")
@app.get("/")
def index():
return responses.HTMLResponse(open("./index.html").read())
@app.post("/data")
async def post(r: Request):
items = await r.json()
for item in items:
db.put(item)
return item
@app.get("/data")
async def get():
return next(db.fetch())
import yfinance
from deta import App, Deta
from fastapi import BackgroundTasks, Depends, FastAPI, Request
from fastapi.templating import Jinja2Templates
from pydantic import BaseModel
deta = Deta()
db = deta.Base("stocks")
app = App(FastAPI())
templates = Jinja2Templates(directory="templates")
class StockRequest(BaseModel):
symbol: str
@app.get("/")
def home(request: Request,
forward_pe=None,
dividend_yield=None,
ma50=None,
ma200=None):
"""
show all stocks in the database and button to add more
button next to each stock to delete from database
filters to filter this list of stocks
button next to each to add a note or save for later
"""
query = {}
if forward_pe:
import json
from fastapi import FastAPI, Request
from fastapi.responses import RedirectResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
from deta import Deta
import secrets
app = FastAPI() # create app instance
deta = Deta("") # provide project key
db = deta.Base("minishort") # create a DetaBase
app.mount("/static", StaticFiles(directory="static"), name="static")
pages = Jinja2Templates(directory="pages")
@app.get("/")
async def get_home(request: Request):
return pages.TemplateResponse("index.html", {"request": request})
@app.post("/shorten")
async def shorten_url(url):
# data = jsonable_encoder(url)
token = secrets.token_urlsafe(6)
db.put(url, key=token)
def post_anchor():
deta = Deta()
db = deta.Base("anchor")
db.put({"key": request.json["anchor_id"], "html": request.json["html"]})
return "created", 201
def __init__(self):
global _deta
if _deta is None:
_deta = Deta(os.getenv('DETA_PROJECT_KEY'))
self.users = _deta.Base('users')
def base_wrapper(name):
deta = Deta(os.environ["DETA_PROJECT_KEY"])
return deta.Base(name)
from fastapi import FastAPI, Form, Request
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import RedirectResponse
import starlette.status as status
from deta import Deta
from datetime import datetime, date
from mail.mail import sender
from uuid import uuid4
from slowapi import Limiter, _rate_limit_exceeded_handler
from slowapi.util import get_remote_address
from slowapi.errors import RateLimitExceeded
limiter = Limiter(key_func=get_remote_address)
deta = Deta() # DetaBase instance
db = deta.Base("akane-contact") # Name of the data base
app = FastAPI() # FastAPI instance
# Rate limit instance
app.state.limiter = limiter
app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
@app.get('/')
async def index(request: Request):
return {'message': 'ok'}
@app.post('/form')
@limiter.limit("5/minute"
import html
from deta import Deta
deta = Deta()
feeds_db = deta.Base("feeds")
items_db = deta.Base("items")
def get_all(db, query):
blob_gen = db.fetch(query)
blobs = []
for stored_blob in blob_gen:
for blob in stored_blob:
blobs.append(blob)
return blobs
def create_feed(title, description, link, feed_link, folder_id):
title = html.unescape(title)
if title == "":
title = "<???>"
try:
feed = feeds_db.put({
"title": title,
"description": description,
"link": link,
"feed_link": feed_link,
"folder_id": folder_id,
})
return feed
def db(self):
deta = Deta(self.deta_key)
return deta.Base(os.environ.get("DETABASE_NAME", "BronzeMedalist"))
from fastapi import FastAPI
from fastapi.staticfiles import StaticFiles
from fastapi.responses import FileResponse
from pydantic import BaseModel
from typing import Optional
from deta import Deta
app = FastAPI()
app.mount("/static", StaticFiles(directory="static"), name="static")
deta = Deta()
db = deta.Base("notebooks")
class Record(BaseModel):
key: str
active: bool
content: str
name: str
public: Optional[bool] = False
class DeleteRecord(BaseModel):
key: str
class NewRecord(BaseModel):
name: str
content: str
@app.get("/")
from datetime import datetime
import base64
from deta import Deta
deta = Deta()
items_db = deta.Base("items")
feeds_db = deta.Base("feeds")
def get_all(db, query):
blob_gen = db.fetch(query)
blobs = []
for stored_blob in blob_gen:
for blob in stored_blob:
blobs.append(blob)
return blobs
def create_items(items):
now = datetime.now()
try:
for i, item in enumerate(items):
if item["guid"] == "":
item["guid"] = item["link"]
item["date_arrived"] = str(now)
item["status"] = "unread"
put_items(items)
return True
except:
return False
import os
from fastapi import FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware
from deta import Deta
from models import Payload
import json
## DetaBase setup
deta = Deta('your_super_secret_deta_key')
db = deta.Base('ot') ## Database name
app = FastAPI() ## FastAPI instance
## Cross-origin resource sharing
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
expose_headers=["*"],
)
## Health check
@app.get('/')
async def index():
return {'hola': 'mundo'}
## Post position from owntracks app to detabase
import base64
import hashlib
import hmac
import json
import os
import requests
from deta import App, Deta
from fastapi import FastAPI, Request, Response
from TwitterAPI import TwitterAPI
fast = FastAPI()
app = App(fast)
deta = Deta()
tweet_box = deta.Base("tweetbox")
TWITTER_CONSUMER_KEY = os.environ.get("TWITTER_CONSUMER_KEY", None)
TWITTER_CONSUMER_SECRET = os.environ.get("TWITTER_CONSUMER_SECRET", None)
TWITTER_ACCESS_TOKEN = os.environ.get("TWITTER_ACCESS_TOKEN", None)
TWITTER_ACCESS_TOKEN_SECRET = os.environ.get("TWITTER_ACCESS_TOKEN_SECRET",
None)
TWITTER_WEBHOOK_ENV = os.environ.get("TWITTER_WEBHOOK_ENV", None)
WEBHOOK_URL = os.environ.get("WEBHOOK_URL", None)
twitterAPI = TwitterAPI(TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET,
TWITTER_ACCESS_TOKEN, TWITTER_ACCESS_TOKEN_SECRET)
@app.get("/webhooks/twitter")
import os
import random
import urllib
from datetime import datetime
from twython import Twython
from deta import App, Deta
from dotenv import load_dotenv
from fastapi import FastAPI
from io import BytesIO
load_dotenv('env')
app = App(FastAPI())
deta = Deta(os.environ.get('PROJECT_KEY'))
db = deta.Base('quotes')
def get_one_random_quote():
# get quotes from deta base
quotes = list(
db.fetch({
'posted_facebook_at': 'NULL',
'posted_telegram_at': 'NULL',
'posted_twitter_at': 'NULL',
}))[0]
# check at least one quote exists
if (len(quotes) == 0):
return None
# get one random quote
return random.choice(quotes)
from pydantic import BaseModel, HttpUrl
from typing import Optional
from .settings import deta_key, deta_pname
from deta import Deta
db = Deta(deta_key).Base(deta_pname)
class URL(BaseModel):
url: HttpUrl
class Pageviews(BaseModel):
url: str
referrer: str
headers: dict
ip: dict
ip_addr: str
day: str
time: str
device: str
device_browser: str
device_type: str
os: str
loadtime: str
hour: Optional[str]
app = FastAPI()
app = FastAPI()
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
expose_headers=["*"],
)
#KEY = os.getenv('DETA_PROJECT_KEY')
deta = Deta('b0dhigbe_TkBCtpTZ8cUfV6aJuHh3HmVjivH26bjh')
db = deta.Base('ot')
@app.get('/', include_in_schema=False)
async def index():
return {'hola': 'mundo'}
@app.post('/position/', include_in_schema=False)
async def post_position(request: Request):
r = await request.body()
r = r.decode('utf-8')
r = json.loads(r)
d = db.update(r, 'viiobn6mj1pf')
return r
from deta import Deta
# initialize with a project key
deta = Deta("a0pnlhsz_TgZroLiYxSrABtU73i1rv5ppbt9ouTav")
# create and use as many DBs as you want!
users = deta.Base("users")
users.insert({"name": "Shokr", "title": "R&D Engineer"})
shokr = next(users.fetch({"name": "Shokr"}))[0]
users.delete(shokr["key"])
from logging import raiseExceptions
from deta import Deta # Import Deta
import httpx
import os
import time
from deta import app
key = os.environ.get("PROJECT_KEY")
if not key:
raiseExceptions("Can not read project key from the envrionment")
# Initialize with a Project Key
deta = Deta(key)
# This how to connect to or create a database.
db = deta.Base("github_stars_db")
def get_github_stars(repo):
if repo:
url = f"https://api.github.com/repos/{repo}"
count = httpx.get(url).json()["stargazers_count"]
return count
else:
return -1
repos = ["PrefectHQ/Prefect", "PrefectHQ/miter-design"]
async def get_user_table() -> Deta.Base:
return Deta(project_id=PROJECT_ID, project_key=PROJECT_KEY).Base(MODEL)
import os
import math
from typing import Optional
from fastapi import FastAPI, Request, status, HTTPException
from fastapi.staticfiles import StaticFiles
from fastapi.responses import FileResponse
from pydantic import BaseModel
from deta import Deta
from folder import create_folder, rename_folder, toggle_folder_expanded, delete_folder
from feed import create_feed, update_feed_folder, rename_feed, delete_feed, get_all
from item import create_items, update_item_status, list_items, count_items, feed_stats
from refresh import fetch_all_feeds
from crawler import discover_feed, convert_items
deta = Deta()
folders_db = deta.Base("folders")
feeds_db = deta.Base("feeds")
items_db = deta.Base("items")
errors_db = deta.Base("feed_errors")
settings_db = deta.Base("settings")
app = FastAPI()
app.mount("/static/", StaticFiles(directory="assets"), name="static")
class New_Folder(BaseModel):
title: str
class Folder(BaseModel):
from fastapi import APIRouter
from deta import Deta
deta = Deta()
db = deta.Base('db_name')
router = APIRouter(prefix='/apip/v2', tags=['API'])
@router.get('/route', status_code=201)
async def get_all_():
result = next(db.fetch())
return result
from flask import Flask, render_template, request, redirect, url_for, flash, abort, session
from deta import Deta
from flask_qrcode import QRcode
import requests
app = Flask(__name__)
jdoodle_url = 'https://api.jdoodle.com/v1/execute'
load_dotenv()
@app.errorhandler(404)
def page_not_found(error):
return render_template('page_not_found.html'), 404
deta = Deta(os.environ['TOKEN'])
codes = deta.Base("codes")
app.config['SECRET_KEY'] = os.environ['SECRET']
app.register_error_handler(404, page_not_found)
qrcode = QRcode(app)
JDOODLEID = os.environ['JDOODLEID']
JDOODLESECRET = os.environ['JDOODLESECRET']
@app.route('/', methods=["GET", "POST"])
def renderMainPage():
if request.method == 'GET':
return render_template('index.html', baseurl=request.base_url)
else:
codename = request.form['codename']
code = request.form['code']
from deta import Deta # Import Deta
import os
# Initialize with a Project Key
deta = Deta()
def connect_toppings():
# This how to connect to or create a database.
return deta.Base("taco_toppings")
def connect_tacos():
# Initialize with a Project Key
# deta = Deta(os.environ['DETA_ACCESS_TOKEN'])
# This how to connect to or create a database.
return deta.Base("taco_tacos")
def connect_user():
# Initialize with a Project Key
deta = Deta(os.environ['DETA_ACCESS_TOKEN'])
# This how to connect to or create a database.
return deta.Base("taco_user")
class DetaBase:
pass
# -*- coding: utf-8 -*-
from deta import Deta
from environs import Env
from fastapi import FastAPI
env = Env()
env.read_env()
deta = Deta(env("DETA_KEY"))
db = deta.Base("chipotle")
app = FastAPI()
@app.get("/")
def read_root():
"""
Root file.
"""
return {"Hello": "World"}
@app.get("/items/{item_id}")
def read_item(item_id: int):
"""
Getting items.
"""
return {"item_id": item_id}
@app.get("/")
def get_stores():
