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']
