import os from airtable import Airtable from keys import AIRTABLE_API_KEY, AIRTABLE_BASE_KEY #Airtable is auto authenticated when you have AIRTABLE_API_KEY set in env airtable_client = Airtable(AIRTABLE_BASE_KEY, 'watch_phrases', api_key=AIRTABLE_API_KEY) #get all phrases def fetch_phrases(): phrases = [] for page in airtable_client.get_iter(): for record in page: fields = record.get('fields', None) if fields: phrases.append(fields['phrase']) else: pass return phrases #add phrase def create_record(phrase): # ensure it's a string if type(phrase) is str: airtable_client.insert({'phrase': phrase}) else: return "That doesn't look like a phrase..."
#!/usr/bin/env python import os import time from airtable import Airtable airtab_active = Airtable(os.environ['jail_scrapers_db'], 'intakes', os.environ['AIRTABLE_API_KEY']) airtab_archive = Airtable(os.environ['jails_archive_db'], 'intakes', os.environ['AIRTABLE_API_KEY']) def archive_intakes(): # the airtable view, 'to be archived', filters intakes to only include those # where the `days_since_verification` field > 60. I have no idea why I'm too # paranoid to add a function to delete the record from the active base once the # record has been successfully added to the archive base, but I am. So I do that # manually after manually verifying that the archived record is actual and complete. records = airtab_active.get_all(view='to be archived') len(records) for record in records: this_dict = {} this_dict['old_record_id'] = record['id'] # this_dict['_charge_1_statute'] = record['fields'].get('_charge_1_statute') # this_dict['_courts'] = record['fields'].get('_courts') # this_dict['_jail'] = record['fields'].get('_jail') # this_dict['_charges'] = record['fields'].get('_charges') # this_dict['_LEA'] = record['fields'].get('_LEA') this_dict['issue(s)'] = record['fields'].get('issue(s)') this_dict['what_changed'] = record['fields'].get('what_changed') this_dict['updated'] = record['fields'].get('updated')
from django.shortcuts import render from django.contrib import messages from airtable import Airtable import os import environ AT = Airtable(os.environ.get('AIRTABLE_MOVIESTABLE_BASE_ID'), 'Movies', api_key=os.environ.get('AIRTABLE_API_KEY')) # Create your views here. def home_page(request): #print(str(request.GET.get('query', ''))) #--- see the resut of input in consol Terminal user_query = str(request.GET.get('query', '')) search_result = AT.get_all(formula="FIND('" + user_query.lower() + "', LOWER({Name}))") stuff_for_frontend = {'search_result': search_result} return render(request, 'movies/movies_stuff.html', stuff_for_frontend)
#!/usr/bin/env /python """This module provides a function for shipping logs to Airtable.""" import os import time from airtable import Airtable import cloudinary from documentcloud import DocumentCloud import tweepy airtab_homicides_by_cop = Airtable(os.environ['police_violence_db'], 'wapo', os.environ['AIRTABLE_API_KEY']) airtab_tweets = Airtable(base_key=os.environ['botfeldman89_db'], table_name='scheduled_tweets', api_key=os.environ['AIRTABLE_API_KEY']) airtab_log = Airtable(base_key=os.environ['log_db'], table_name='log', api_key=os.environ['AIRTABLE_API_KEY']) auth = tweepy.OAuthHandler(os.environ['TWITTER_APP_KEY'], os.environ['TWITTER_APP_SECRET']) auth.set_access_token(os.environ['TWITTER_OAUTH_TOKEN'], os.environ['TWITTER_OAUTH_TOKEN_SECRET']) tw = tweepy.API(auth) cloudinary.config(cloud_name='bfeldman89', api_key=os.environ['CLOUDINARY_API_KEY'], api_secret=os.environ['CLOUDINARY_API_SECRET']) dc = DocumentCloud(username=os.environ['DOCUMENT_CLOUD_USERNAME'], password=os.environ['DOCUMENT_CLOUD_PW'])
def get_airtable_table(table_name): return Airtable(AIRTABLE_BASE_KEY, table_name, api_key=AIRTABLE_API_KEY)
table_names = [ 'Technical Domain', 'Disaster Domain', 'Healthcare Domain', 'Content since 10/29' ] # Create defaultdict structures technical_domain_records_list = defaultdict(list) disaster_domain_records_list = defaultdict(list) healthcare_domain_records_list = defaultdict(list) content_since_records_list = defaultdict(list) # Go through the data retrieved from each of the tables listed above for table in table_names: # AirTable API setup - replace the values with your own airtable = Airtable('base-key', table, api_key='your-api-key') # Get only records that are in the correct Status records = airtable.get_all(view='Keep') # Process each record from AirTable for record in records: # For ease of code writing record = record['fields'] # Topic might not be provided, catch this error try: topic = record['Topic'] except KeyError: topic = "EMPTY"
def base_airtable_inserir(base_k, table_n, novos_dados): from airtable import Airtable airtable = Airtable(base_k, table_n, api_key=airtable_api) data = {'Name': novos_dados} airtable.insert(data)
pd.options.mode.chained_assignment = None page = urlopen(url) soup = BeautifulSoup(page, "html.parser") html = soup.find( "table", attrs={ "class": "Table2__table-scroller Table2__right-aligned Table2__table" }) table = pd.read_html(html.prettify()) df = table[0] df['PLAYER'] = df['PLAYER'].str.replace("'", "") df = df.set_index("PLAYER") df.to_csv('espnfield.csv') airtable = Airtable(base_key, table_name, AIRTABLE_API_KEY) field = airtable.get_all() field = pd.DataFrame.from_dict(field) field_data = [0] * len(field) for (i, entry) in enumerate(field_data): entry = field.loc[i]['fields'] field_data[i] = entry field_data = pd.DataFrame.from_dict(field_data) field_data = field_data.join(df, on='PLAYER') field_data = field_data.set_index('New_Index') field_data['TODAY'].replace(to_replace='E', value=0, inplace=True) field_data['TODAY'].replace(to_replace='-', value=0, inplace=True) field_data['TODAY'] = field_data['TODAY'].fillna(0)
# install it pip uninstall airtable pip install airtable-python-wrapper # import it from airtable import Airtable #intilize airtable1 = Airtable(api_key='key7BnLq2O4dACj81', table_name='leading_ads', base_key='appPzGUWNjmOLCJqG') #for loop on list for info in airtable1.get_all(): print(info['fields']) #update record airtable1.update(info['id'], {'Profile_name': 'Ready'}) #replace whole row fields = {'PassangerName': 'Mike', 'Passport': 'YASD232-23'} airtable1.replace(record['id'], fields) #or send the dic #saving screen shots dbx = dropbox.Dropbox( 'key') def save_screenshot(driver, profile_name, row_id): filename = profile_name + ".png"
def __init__(self): """Initialize AirtableClient.""" self.airtable_client = Airtable(os.getenv("airtable_base_id"), app.config["AIRTABLE_TABLE_NAME"], os.getenv("airtable_api_key"))
from airtable import Airtable from dotenv import load_dotenv from django.views.generic import FormView, DetailView, UpdateView from django.urls import reverse_lazy from django.shortcuts import render, redirect, reverse from django.core.paginator import Paginator from users import models as user_models from users import views as user_views from . import models, forms, apps from datetime import datetime from config.settings import SERVER load_dotenv() api_key = os.getenv("API_KEY") base_key = os.getenv("BASE_ID") airtable = Airtable(base_key, "dataBase", api_key) air_view = os.getenv("AIR_VIEW") if SERVER == "l": root_url = "http://127.0.0.1:8000/" elif SERVER == "s": root_url = "https://hpdjango.herokuapp.com/" import_export = ["임진석", "심동현", "임진아", "진석"] sales = ["임진강", "나준호"] total = ["정소영", "이선화", "추승혜", "송혜주"] def intro(request): return render(request, "issues/intro.html")
send_text_message(sender_id, "Processing...") send_colored_image(sender_id, image_url) if len(attachments) == 2: content_image_url = event["message"]["attachments"][0]["payload"][ "url"] style_image_url = event["message"]["attachments"][1]["payload"][ "url"] send_text_message(sender_id, "Processing...") send_neural_style_image(sender_id, content_image_url, style_image_url) airtable = Airtable(base_key, table_name, api_key=os.environ['AIRTABLE_API_KEY']) def send_colored_image(recipient_id, image_url): r = requests.post("https://api.deepai.org/api/colorizer", data={ 'image': image_url, }, headers={'api-key': 'DEEP-AI_API_KEY'}) colored_image = r.json()['output_url'] message_data = json.dumps({ "recipient": {
import urllib from urllib.request import urlopen, Request import ast import json from datetime import datetime load_dotenv() app = Flask(__name__) places_table = Airtable(os.getenv("AIRTABLE_BASE"), 'Places', os.getenv("AIRTABLE_KEY")) @app.route('/', methods=['GET']) def home(): return render_template('index.html') @app.route('/create', methods=['POST']) def create(): record = places_table.insert({"Place Name": str(request.form['place-name']),}) return render_template('done.html', id=record['id']) if __name__ == '__main__': from os import environ
class GeocoderPipeline(object): def __init__(self, session=None): if session is None: session = requests.Session() self.session = session self.client = MapzenAPI(os.environ.get('MAPZEN_API_KEY')) self.geocode_database = Airtable(AIRTABLE_BASE_KEY, AIRTABLE_GEOCODE_TABLE) def process_item(self, item, spider): """ Geocodes an item by: (1) looking in airtable cache (2) making a mapzen query and adding the result to the cache if (1) is not found Mapzen queries are standardized to end with ', Chicago, IL'. If something like '5100 Milwaukee Chicago, IL' is not found, '5100 Milwaukee Ave., Chicago, IL' and '5100 Milwaukee St., Chicago, IL' are also tried. """ # skip geocoding if event is in the past if item.get('start_time') is None: spider.logger.debug( 'GEOCODER PIPELINE: Ignoring event without start_time {0}'. format(item['id'])) return item dt = dateutil.parser.parse(item['start_time']) if dt < datetime.datetime.now(dt.tzinfo): spider.logger.debug( 'GEOCODER PIPELINE: Ignoring past event {0}'.format( item['id'])) return item query = self._get_mapzen_query(item.get('location', {})) if not query: spider.logger.debug( 'GEOCODER PIPELINE: Empty query. Not geocoding {0}'.format( item['id'])) return item for suffix in ['', ' ave.', ' st.']: new_query = query.replace(', chicago, il', '{0}, chicago, il'.format(suffix)) time.sleep(randint(0, 3)) # to avoid rate limiting? updated_item = self._update_fromDB(new_query, item) if updated_item: spider.logger.debug( 'GEOCODER PIPELINE: Geocoded item from airtable cache.') return updated_item bad_addresses = ['Chicago, IL, USA', 'Illinois, USA', ''] for suffix in ['', ' ave.', ' st.']: new_query = query.replace(', chicago, il', '{0}, chicago, il'.format(suffix)) geocoded_item = self._geocode(new_query, item, spider) address = geocoded_item['location']['address'] if (address not in bad_addresses) and (address.endswith( 'Chicago, IL, USA')) and (self._hasDigit(address)): write_item = { 'mapzen_query': new_query, 'longitude': geocoded_item['location']['coordinates']['longitude'], 'latitude': geocoded_item['location']['coordinates']['latitude'], 'name': geocoded_item['location']['name'], 'address': geocoded_item['location']['address'], 'geocode': geocoded_item['geocode'], 'community_area': geocoded_item['community_area'] } self._geocodeDB_write(spider, write_item) spider.logger.debug( 'GEOCODER PIPELINE: Geocoded item from mapzen.') return geocoded_item spider.logger.exception(( "GEOCODER PIPELINE: Couldn't geocode using mapzen or airtable cache. " "Query: {0}. Item id: {1}").format(query, item['id'])) return item def _geocode(self, query, item, spider): """ Makes a Mapzen query and returns results. """ try: geocode = self.client.search(query, boundary_country='US', format='keys') except ValueError: spider.logger.debug( ('GEOCODER PIPELINE: Could not geocode, skipping. ' 'Query: {0}. Item id: {1}').format(query, item['id'])) except Exception as e: spider.logger.info( ('GEOCODER PIPELINE: Unknown error when geocoding, skipping. ' 'Query: {0}. Item id: {1}. Message: {2}').format( query, item['id'], str(e))) else: new_data = { 'location': { 'coordinates': { 'longitude': str(geocode['features'][0]['geometry']['coordinates'] [0]), 'latitude': str(geocode['features'][0]['geometry']['coordinates'] [1]) }, 'name': geocode['geocoding']['query']['parsed_text'].get( 'query', ''), 'address': geocode['features'][0]['properties']['label'], 'url': item.get('location', { 'url': '' }).get('url', '') }, 'geocode': json.dumps(geocode, indent=4, sort_keys=True), 'community_area': geocode['features'][0]['properties'].get('neighbourhood', '') } geocoded_item = item.copy() geocoded_item.update(new_data) return geocoded_item return {'location': {'address': ''}} def _hasDigit(self, string): """ Returns True if the string contains a digit. """ return any(char.isdigit() for char in string) def _get_mapzen_query(self, location_dict): """ Clean and item's location to make a mapzen query. All cleaned queries are lowercase and end with ', chicago, il'. """ name = location_dict.get('name', '').strip() address = location_dict.get('address', '').strip() query = ', '.join([ name, address ]).strip(', ').lower() # combine '{name}, {address}' and lowercase query = query.replace('-', ' ').replace('/', ' ') # remove special characters query = query.replace('milwukee', 'milwaukee').replace( 'milwuakee', 'milwaukee') # fix misspellings query = query.replace('n.', 'n. ').replace('s.', 's. ').replace( 'e.', 'e. ').replace('w.', 'w. ') query = re.sub(r' +', ' ', query) # remove repeated spaces query = re.sub(r',* chicago,*( il)* *\d*$', ', chicago, il', query) # remove zip code, standardize ', chicago, il' if not query: return '' if 'city hall' in query.lower(): return 'chicago city hall, chicago, il' if not query.endswith(', chicago, il'): return '{0}, chicago, il'.format(query) else: return query def _update_fromDB(self, query, item): """ Query the geocode database and update item with results. """ fetched_item = self._geocodeDB_fetch(query) try: new_data = { 'location': { 'coordinates': { 'longitude': str(fetched_item['longitude']), 'latitude': str(fetched_item['latitude']) }, 'name': fetched_item.get('name', ''), 'address': fetched_item['address'], 'url': item.get('location', { 'url': '' }).get('url', '') }, 'geocode': str(fetched_item.get('geocode', '')), 'community_area': fetched_item.get('community_area', '') } except: return {} else: updated_item = item.copy() updated_item.update(new_data) return updated_item def _geocodeDB_fetch(self, query): """ Fetch from geocode_database. """ try: return self.geocode_database.match('mapzen_query', query)['fields'] except: return None def _geocodeDB_write(self, spider, item): """ Write to geocode_database. """ spider.logger.debug('GEOCODER PIPELINE: Caching {0}'.format( item['mapzen_query'])) item['geocode_date_updated'] = datetime.datetime.now().isoformat() airtable_item = self.geocode_database.match('mapzen_query', item['mapzen_query']) if airtable_item: self.geocode_database.update_by_field('mapzen_query', item['mapzen_query'], item) else: self.geocode_database.insert(item)
def test_authorization_fail(self, ): with pytest.raises(ValueError) as excinfo: # Raises Invalid Base Key or Table Name fake_airtable = Airtable(base_key='XXX', table_name='YYY') errmsg = str(excinfo.value).lower() assert 'invalid' in errmsg and 'base' in errmsg
from airtable import Airtable # AirTable API setup - the base and table name is correct, just add your API key airtable = Airtable('appaS7Pu6nvkdBNiW', 'Events', api_key='your-api-key') # Get all records records = airtable.get_all() # Create defaultdict structure records_list = [] # Process each record from AirTable for record in records: # For ease of code writing record = record['fields'] # Get records and format appropriately name = record['Name'].split("-")[0].strip().replace("'", "") category = record['Category'] description = record['Description'].replace("'", "") country = record['Country'] start_date = record['Start Date'] # City might not be provided, catch this error try: city = record['City'] city_slug = city.lower().strip().replace(" ", "-") except KeyError: city = "" city_slug = ""
tournament_id='401056556' AIRTABLE_API_KEY = 'keybBQGNdYeJkRwcs' base_key = 'appmCQ7CzGefKPdmu' url = 'http://www.espn.com/golf/leaderboard?tournamentId='+str(tournament_id) pd.options.mode.chained_assignment = None page = urlopen(url) soup = BeautifulSoup(page, "html.parser") html = soup.find("table", attrs={"class": "Table2__table-scroller Table2__right-aligned Table2__table"}) table= pd.read_html(html.prettify()) df = table[0] df = df.set_index("PLAYER") table_name = 'USOPEN_FIELD' airtable = Airtable(base_key, table_name, AIRTABLE_API_KEY) field = airtable.get_all() field = pd.DataFrame.from_dict(field) field_data= [0]*len(field) for (i, entry) in enumerate(field_data): entry = field.loc[i]['fields'] field_data[i] = entry field_data = pd.DataFrame.from_dict(field_data) field_data = field_data.join(df, on='PLAYER') field_data = field_data.set_index('New_Index') field_data['TODAY'].replace(to_replace='E',value=0, inplace=True) field_data['TODAY'].replace(to_replace='-',value=0, inplace=True) field_data['TODAY'].astype('int64')
from airtable import Airtable # type: ignore from .config import api_key, base_key artist_airtable = Airtable( base_key=base_key, table_name="Artist", api_key=api_key, ) label_airtable = Airtable( base_key=base_key, table_name="Label", api_key=api_key, ) release_airtable = Airtable( base_key=base_key, table_name="Release", api_key=api_key, ) track_airtable = Airtable( base_key=base_key, table_name="Track", api_key=api_key, )
from flask_login import LoginManager from flask_cors import CORS from flask_bootstrap import Bootstrap from flask_moment import Moment from airtable import Airtable # from flask_socketio import SocketIO, emit from config import Config from include.credentials import * import logging from logging.handlers import RotatingFileHandler app = Flask(__name__) Config.SECRET_KEY = SECRET_KEY # so that SECRET_KEY can be stored in secure credentials.py file app.config.from_object(Config) db = SQLAlchemy(app) migrate = Migrate(app, db) CORS(app) login = LoginManager(app) bootstrap = Bootstrap(app) moment = Moment(app) base = Airtable('app2FkHOwb0jN0G8v', 'Activities', api_key=AIRTABLE_API_KEY) login.login_view = 'login' handler = RotatingFileHandler('error.log', maxBytes=10000, backupCount=1) handler.setLevel(logging.INFO) app.logger.addHandler(handler) DEFAULT_SUBDOMAIN = "www" from app import routes
def table(constants): return Airtable(constants["API_KEY"], constants["TABLE_NAME"], api_key=constants["BASE_KEY"])
def get_records(table): airtable = Airtable(APP_ID, table, api_key=APP_KEY) return airtable.get_all()
from django.shortcuts import render, redirect from django.contrib import messages from airtable import Airtable import os BASE_ID = 'app6TYLiaDsGTRv5Z' TABLE_NAME = 'Movies' AIRTABLE_API_KEY = 'keywZuilsR8tLK47W' AT = Airtable(BASE_ID, 'Movies', api_key=AIRTABLE_API_KEY ) def home_page(request): user_query = str(request.GET.get('query', '')) search_result = AT.get_all(formula="FIND('" + user_query.lower() + "', LOWER({Name}))") stuff_for_frontend = {'search_result': search_result} return render(request, 'movies/movies_stuff.html', stuff_for_frontend) def create(request): if request.method == 'POST': data = { 'Name': request.POST.get('name'), 'Pictures': [{'url': request.POST.get('url') or 'https://www.classicposters.com/images/nopicture.gif'}], 'Rating': int(request.POST.get('rating')), 'Notes': request.POST.get('notes') } try: response = AT.insert(data)
#! python from airtable import Airtable import discord, fstrings, re, random, os from datetime import datetime # datetime object containing current date and time AIRTABLE_API_KEY = os.getenv('AIRTABLE_API_KEY') # stored in .env AIRTABLE_BASE_KEY = os.getenv('AIRTABLE_BASE_KEY') # stored in .env CAMPAIGN_NAME = os.getenv('CAMPAIGN_NAME') campaign_airtable = Airtable(AIRTABLE_BASE_KEY, 'Campaign') party_airtable = Airtable(AIRTABLE_BASE_KEY, 'Parties') characters_airtable = Airtable(AIRTABLE_BASE_KEY, 'Characters') scenario_airtable = Airtable(AIRTABLE_BASE_KEY, 'Scenarios') items_airtable = Airtable(AIRTABLE_BASE_KEY, 'Items') # items record lookup abilities_airtable = Airtable(AIRTABLE_BASE_KEY, 'Character Abilities') # abilities record lookup classes_airtable = Airtable(AIRTABLE_BASE_KEY, 'Character Classes') # class record lookup storylines_airtable = Airtable(AIRTABLE_BASE_KEY, 'Storylines') players_airtable = Airtable(AIRTABLE_BASE_KEY, 'Players') achievements_airtable = Airtable(AIRTABLE_BASE_KEY, 'Achievements') class Player: character_levels = (0, 45, 95, 150, 210, 275, 345, 420, 500) prosperity_levels = (0, 4, 9, 15, 22, 30, 39, 50, 64) def __init__(self, author): self.name = author
# Helper functions for transforming data & querying AirTable import os from airtable import Airtable volunteer_table = Airtable( os.getenv("AIRTABLE_BASE_KEY"), os.getenv("AIRTABLE_TABLE_NAME")) class AirTableLinkedRecords(object): """Class to look up linked records in the specified AirTable table. """ def __init__(self, table_name, key_col="Name", use_cache=True): self.name = table_name self.key_col = key_col self._cache = {} self._table = None self._use_cache = use_cache def __getitem__(self, record_name): try: return self._cache[record_name] except KeyError: record_id = self.record_id_by_name(record_name) if self._use_cache is True: self._cache[record_name] = record_id return record_id @property def table(self):
from django.shortcuts import render, redirect from django.contrib import messages from airtable import Airtable import os AT = Airtable(os.environ.get('AIRTABLE_MOVIESTABLE_BASE_ID', "appfgHVoMPSAiJrxC"), 'Movies', api_key=os.environ.get('AIRTABLE_API_KEY', "keyywHQHfPLsbgHmK")) # Create your views here. def home_page(request): user_query = str(request.GET.get('query', '')) search_result = AT.get_all( formula="FIND('" + user_query.lower() + "', LOWER({Name}))") stuff_for_frontend = {'search_result': search_result} return render(request, 'movies/movies_stuff.html', stuff_for_frontend) def create(request): if request.method == 'POST': data = { 'Name': request.POST.get('name'), 'Pictures': [{'url': request.POST.get('url') or 'https://www.classicposters.com/images/nopicture.gif'}], 'Rating': int(request.POST.get('rating')), 'Notes': request.POST.get('notes') } try:
def table(self): """Lazily load the AirTable object""" if self._table is None: self._table = Airtable(os.getenv("AIRTABLE_BASE_KEY"), self.name) return self._table
# import libraries import re import tweepy import os import time from airtable import Airtable from secrets import * from urllib import request from bs4 import BeautifulSoup import datetime at = Airtable(os.environ['airtable_indextrump_base'], 'TrumpIndex', api_key=os.environ['airtable_apikey']) def send_tweet(paper, trumpindex): # Twitter requires all requests to use OAuth for authentication auth = tweepy.OAuthHandler(os.environ["consumer_key"], os.environ["consumer_secret"]) auth.set_access_token(os.environ["access_token"], os.environ["access_secret"]) #Construct the API instance api = tweepy.API(auth) # create an API object user = api.me() print(user.name) update = "Today's " + paper[0] + " homepage features " + str(
#!/usr/bin/env python # coding: utf-8 # In[2]: from selenium import webdriver from time import sleep from selenium.webdriver.common.keys import Keys from selenium.webdriver.common.by import By from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_conditions as EC from airtable import Airtable from Google import Create_Service, convert_to_RFC_datetime airtable = Airtable(api_key='api_key', table_name='table_name', base_key='base_key') from time import sleep # In[100]: driver = webdriver.Chrome("chromedriver.exe") driver.set_window_size(1366, 768) # In[101]: driver.get("https://slate.uol.edu.pk") auth_link = driver.find_element_by_xpath( "//a[contains(@href,'oauth2')]").get_attribute('href') driver.get(auth_link) email_input = driver.find_element_by_xpath("//input[@type='email']") email_input.send_keys("*****@*****.**")
import slack import os from airtable import Airtable from pprint import pprint from requests.exceptions import HTTPError from datetime import datetime, timedelta import pandas as pd from flask import Blueprint, request, abort, make_response, render_template from jinja2 import TemplateNotFound f"This should be run in Python 3.6 or higher" baseid = os.environ.get('AIRTABLE_BASE') AIRTABLE_TABLENAME = os.environ.get('AIRTABLE_TICKET_TABLE_NAME', 'Tickets') AIRTABLE_TABLEID = os.environ.get('BASE_TICKETS', 'tblA4zbHiw2Lqyvzo') tickets_table = Airtable(baseid, AIRTABLE_TABLENAME) verification_token = os.environ.get('VERIFICATION_TOKEN') slo = Blueprint('slo', __name__, template_folder='templates') @slo.route('/slo') def slo_main(): "Main and only page for SLO" ontime, groupmeans, groupsizes = runstats(getdonedusted()) response = make_response( render_template('slo_page.html', ontime=ontime, groupmeans=groupmeans, groupsizes=groupsizes)) response.headers.set('Pragma', 'No-Cache')
import discord import os import json from dotenv import load_dotenv from airtable import Airtable import random load_dotenv() intents = discord.Intents().default() intents.members = True client = discord.Client(intents=intents) airtable = Airtable(os.getenv('AIRTABLE_API_KEY'), os.getenv('AIRTABLE_BASE_URL'), "appqLAIXpfmBRorop") @client.event async def on_ready(): print('We have logged in as {0.user}'.format(client)) @client.event async def on_member_join(member): channel = client.get_channel(800981464828215296) member_details = airtable.get_members_by_discord_id( str(member), "tblB9sWiSRn2pVG2E") member_details = json.loads(member_details.text) notes = "" try: notes = member_details['records'][0]['fields']['notes']