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():