def send_it(errorList): dotenv.load() message = Mail( from_email='*****@*****.**', to_emails='*****@*****.**', subject='Sending with Twilio SendGrid is Fun', ) print(errorList) #Using os won't work for Chrome extension... message.dynamic_template_data = { 'row': errorList, } message.template_id = dotenv.get('TEMPLATE_ID') print(dotenv.get('SENDGRID_API_KEY')) sg = SendGridAPIClient(dotenv.get('SENDGRID_API_KEY')) try: response = sg.send(message) print(response.status_code) print(response.body) print(response.headers) except exceptions.BadRequestsError as e: print(e.body) exit() print(response.status_code, response.body, response.headers)
def __init__(self): self.consumer = KafkaConsumer(auto_offset_reset='earliest', bootstrap_servers=[ dotenv.get('IOT_DOMAIN') + ':' + str(dotenv.get('IOT_KAFKA_PORT')) ]) self.consumer.subscribe(['db'])
def upload(): file = open(os.path.abspath('blah.txt'),'rb') print file.name key = 'blah.txt' if upload_to_s3(dotenv.get('AWS_ACCESS_KEY'), dotenv.get('AWS_SECRET_KEY'), file, dotenv.get('S3_BUCKET'), key): return 'success' else: return 'fail'
def __init__(self, consumer): self.consumer = consumer self.cnx = mysql.connector.connect( user=dotenv.get('MYSQL_USER'), password=dotenv.get('MYSQL_PASSWORD'), host=dotenv.get('MYSQL_HOST'), database=dotenv.get('MYSQL_DATABASE')) self.cursor = self.cnx.cursor()
def handleAuth(): consumer_key = dotenv.get('ENV_KEY') consumer_secret = dotenv.get('ENV_SECRET') access_key = dotenv.get('TOKEN_KEY') access_secret = dotenv.get('TOKEN_SECRET') auth = tweepy.OAuthHandler(consumer_key, consumer_secret) auth.set_access_token(access_key, access_secret) return auth
def _get_params_from_dotenv(): dotenv.load("../.env") return { 'database': dotenv.get('DATABASE'), 'user': dotenv.get('DBUSER'), 'host': dotenv.get('HOST'), 'password': dotenv.get('PASSWORD') }
def create_cx_oracle_conn(): dsnStr = cx_Oracle.makedsn(dotenv.get('POWERSCHOOL_HOST'), dotenv.get('POWERSCHOOL_PORT', '1521'), dotenv.get('POWERSCHOOL_DATABASE')) connection = cx_Oracle.connect(dotenv.get('POWERSCHOOL_USER'), dotenv.get('POWERSCHOOL_PASSWORD'), dsn=dsnStr) return connection
def make_api_request(self, endpoint, params=None): url = dotenv.get('GITLAB_URL') or 'https://gitlab.com/' if not url.endswith('/'): url = '{}/'.format(url) headers = {'PRIVATE-TOKEN': dotenv.get('GITLAB_TOKEN')} api_endpoint = '{url}{endpoint}'.format(url=url, endpoint=endpoint) response = requests.get(api_endpoint, headers=headers, params=params) return response.json()
def next_trips_for_stop(stop_no: int, route_no: int) -> dict: if not (dotenv.get('APP_ID') or dotenv.get('API_KEY')): raise NameError('MissingAPIandAPPID') return requests.post('https://api.octranspo1.com/v1.2/GetNextTripsForStop', data={ "appID": dotenv.get('APP_ID'), "apiKey": dotenv.get('API_KEY'), "stopNo": stop_no, "routeNo": route_no, "format": "json" }).json()
def main(): now = datetime.utcnow() start = get_range_start(now) end = datetime(now.year, now.month, 1, 0, 0, 1) dotenv.load() total_miles = get_total_miles(start, end, dotenv.get("STRAVA_TOKEN")) message = "Total Mileage for month of {0}: {1} miles".format( calendar.month_name[get_prev_month(now)], total_miles) send_email(message, dotenv.get("EMAIL_TO"), dotenv.get("EMAIL_FROM"), dotenv.get("EMAIL_PWD"))
def __init__(self): self.gateway_ip = dotenv.get('KNX_GATEWAY') self.gateway_port = dotenv.get('KNX_GATEWAY_PORT') self.endpoint_port = dotenv.get('KNX_ENDPOINT_PORT') # -> Socket creation self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.sock.bind(('', self.endpoint_port)) # -> in this example, for the sake of simplicity, the two ports are the same # With the simulator, the gateway_ip must be set to 127.0.0.1 and gateway_port to 3671 self.data_endpoint = (self.gateway_ip, self.endpoint_port) self.control_endpoint = (self.gateway_ip, self.endpoint_port) self.conn_channel_id = self.create_connexion()
def save_as_pdf(s): try: m = re.search('http://www.geeksforgeeks.org/(.+?)/', s) if m: filename = m.group(1) else: filename = ''.join(choice(ascii_uppercase) for i in range(12)) client = pdfcrowd.Client(dotenv.get('akhileshk'), dotenv.get('api-key')) output_file = open('BST_' + filename + '.pdf', 'wb') html = get_page(s) client.convertHtml(html, output_file) output_file.close() except pdfcrowd.Error, why: print 'Failed: ', why
def run(cities: list) -> list: """ Main run function. Obtains client with API key and creates/returns distance_data file depending on whether the file exists :rtype: list :param cities: list :return: upper triangular matrix of distances """ client = Client(key=dotenv.get('API_KEY')) try: is_empty = os.stat('distance_data').st_size == 0 if is_empty: with open('distance_data', mode='wb') as data_file: matrix = iter_gather(client, cities) pickle.dump(matrix, data_file) return matrix else: with open('distance_data', mode='r+b') as data_file: matrix = pickle.load(data_file) if len(matrix) != len(cities): matrix = iter_gather(client, cities) file_bytes = pickle.dumps(matrix) data_file.seek(0) data_file.write(file_bytes) data_file.truncate() return matrix except FileNotFoundError: with open('distance_data', mode='ab') as data_file: matrix = iter_gather(client, cities) pickle.dump(matrix, data_file) return matrix
def env(key, default=None): value = dotenv.get(key, default) if value == 'True': value = True elif value == 'False': value = False return value
def geocode_location(location): """ Returns lat and lon based on an input string representing location :param location: String representing location to geocode :returns: Tuple (lat,lon) of geocoded location """ api_base_url = "https://maps.googleapis.com/maps/api/geocode/json?" dotenv.load() API_KEY = dotenv.get('GOOG_API_KEY') api_base_url += "address=" + str(location) api_base_url += "&key=" + API_KEY res = requests.get(api_base_url) if not res.ok: raise CantAccessAPI( "Unable to access Google Maps API. Check your connection and API key" ) res_obj = res.json() if res_obj["status"] != "OK": raise CandFindLocation("Location is invalid") else: lat = res_obj["results"][0]["geometry"]["location"]["lat"] lon = res_obj["results"][0]["geometry"]["location"]["lng"] return (lat, lon)
class ProductionConfig(Config): """ The configuration settings for production mode is defined here. Attributes such as SQLALCHEMY_DATABASE_URI, DEBUG are different for other modes, so they are defined in a class called ProductionConfig. """ SQLALCHEMY_DATABASE_URI = dotenv.get("DATABASE_URL")
def __init__(self): dotenv.load() self.mailgun_api_key = dotenv.get('MAILGUN_API_KEY') if self.mailgun_api_key is None: raise Exception( "mailgun_key is None, it's probably caused by missing .env config file on folder." ) self.init_email_fields()
def get_total_miles(start, end, token): dotenv.load() client = Client(dotenv.get("STRAVA_TOKEN")) total_miles = 0 for activity in client.get_activities(after=start, before=end): total_miles += unithelper.miles(activity.distance).num return int(total_miles)
def reiniciar_config(): dotenv.load("./.env") Config.OFFSET_INCREMENTO = dotenv.get("OFFSET_INCREMENTO") Config.PAYLOAD = { "tiposinstrumentos": dotenv.get("TIPOS_INSTRUMENTOS"), "TiposJudiciales": dotenv.get("TIPOS_JUDICIALES"), "TiposComunes": dotenv.get("TIPOS_COMUNES"), "fechaboletin1": dotenv.get("FECHA_1"), "fechaboletin2": dotenv.get("FECHA_2"), "offset": dotenv.get("OFFSET"), "Submit": dotenv.get("SUBMIT"), }
def gtfs(table: str, id_=None, column=None, value=None, limit=None) -> dict: if not (dotenv.get('APP_ID') or dotenv.get('API_KEY')): raise NameError('MissingAPIandAPPID') data = { "appID": dotenv.get('APP_ID'), "apiKey": dotenv.get('API_KEY'), "table": table, "format": "json" } data.update({ k: v for k, v in { 'id': id_, 'column': column, 'value': value, 'limit': limit }.items() if v }) return requests.post('https://api.octranspo1.com/v1.2/Gtfs', data=data).json()
class Config: """ The definition of the global configuration is defined here. Attributes such as SECRET_KEY are the same no matter the platform used. """ SECRET_KEY = dotenv.get("SECRET_KEY") SQLALCHEMY_COMMIT_ON_TEARDOWN = True SQLALCHEMY_TRACK_MODIFICATIONS = False DEBUG = False
class DevelopmentConfig(Config): """ The configuration settings for development mode is defined here. Attributes such as SQLALCHEMY_DATABASE_URI, DEBUG are different for other modes, so they are defined in a class called DevelopmentConfig. """ SQLALCHEMY_DATABASE_URI = dotenv.get("DATABASE_URL") SQLALCHEMY_TRACK_MODIFICATIONS = True DEBUG = True
def send(message, url): server = smtplib.SMTP('smtp.gmail.com', 587) server.ehlo() server.starttls() server.ehlo() server.login(dotenv.get('SENDER'), dotenv.get('PASSWORD')) if isinstance(message, list): subject = message[0] + " Price change!" body = message[0] +" new price is " + message[1] +'\n' + "Prior price was " + message[2] + '\n' + 'Get it here: \n' + url else: subject = message body = message + ": " + url # print(message) msg = f"Subject: {subject}\n\n{body}" server.sendmail( dotenv.get('SENDER'), dotenv.get('RECIPIENT'), msg ) # print("email has been sent") server.quit()
def main(timestamp_start, timestamp_end, column_index_list, list_of_column_index_list, axis_label_list): # wrapper function try: dotenv.load(get_current_directory() + '/.env') start_time = time.time() date = get_date_from_timestamp(timestamp_start) #plot graph plot_graph(list_of_column_index_list, timestamp_start, timestamp_end, axis_label_list) total_attachments = len(list_of_column_index_list) # compose the email fromaddr = dotenv.get("From") toaddr = dotenv.get("To") cc = dotenv.get("Cc") bcc = dotenv.get("Bcc") rcpt = [cc] + [bcc] + [toaddr] #generate html code for email body html_body = (generate_report_table_html(column_index_list, timestamp_start, timestamp_end, total_attachments)) #send mail with graphs and table send_mail(date, fromaddr, toaddr, cc, bcc, rcpt, html_body, total_attachments) end_time = time.time() logger.info('Time taken to execute %s(): %s secs' % (inspect.currentframe().f_code.co_name, "{0:.2f}".format(end_time - start_time))) except Exception, e: logger.exception(str(e)) end_time = time.time() logger.info('Time taken to execute %s(): %s secs' % (inspect.currentframe().f_code.co_name, "{0:.2f}".format(end_time - start_time))) quit()
def run(cities): try: with open('coordinates_data', 'r+b') as data_file: data = pickle.load(data_file) if len(cities) != len(data): client = gmaps.Client(dotenv.get('GEOCODING_API_KEY')) print('Generating coordinate data...') data = { cities.index(c): get_geocode(client, c) for c in cities } file_bytes = pickle.dumps(data) data_file.seek(0) data_file.write(file_bytes) data_file.truncate() return data except FileNotFoundError: client = gmaps.Client(dotenv.get('GEOCODING_API_KEY')) print('Generating coordinate data...') data = {cities.index(c): get_geocode(client, c) for c in cities} with open('coordinates_data', 'ab') as data_file: pickle.dump(data, data_file) return data
def get_campgrounds_from_API(latitude, longitude, radius): """ Calls Recreation.gov API with a location and search radius, and returns URLs and campground names Returns a list of dicts, with two key-value pairs: campground name and URL Returns an empty list if no campgrounds found :param latitude: Latitude of coordinate to center the search around :param longitude: Longitude of coordinate to center the search around :param radius: Radius to search around """ dotenv.load() API_KEY = dotenv.get('REC_API_KEY') api_url = "https://ridb.recreation.gov/api/v1/facilities.json?apikey=" api_url += API_KEY api_url += "&activity=9" api_url += "&latitude=" + str(latitude) api_url += "&longitude=" + str(longitude) api_url += "&radius=" + str(radius) # Gets campgrounds from RIDB API res = requests.get(api_url) if not res.ok: raise CantAccessAPI( "Unable to access RIDB API. Check your connection and API key") res_list = res.json()["RECDATA"] # Constructs list of Campgrounds results = CampgroundList() base_url = "https://www.recreation.gov/camping/" base_url_suffix = "/r/campgroundDetails.do?contractCode=NRSO&parkId=" print(res.json()) for idx, campsite in enumerate(res_list): facility_name = campsite['FacilityName'].lower().replace(" ", "-") if campsite['LegacyFacilityID']: facilityID = str(int(campsite['LegacyFacilityID'])) campground_url = base_url + facility_name + base_url_suffix + facilityID name = " ".join(w.capitalize() for w in res_list[idx]['FacilityName'].split()) results.append(Campground(name, campground_url)) return results
def test_get_quoted_string(self): """ Test return value is of the correct type <string> """ self.assertIs(type(dotenv.get('QUOTED_STRING')), str) self.assertEqual('True', dotenv.get('QUOTED_STRING'))
def test_get_boolean(self): """ Test return value is of the correct type <bool> """ self.assertIs(type(dotenv.get('BOOLEAN')), bool) self.assertFalse(dotenv.get('BOOLEAN'))
def connect(): return psycopg2.connect(host=dotenv.get('HOSTNAME'), port=dotenv.get('PORT'), user=dotenv.get('USERNAME'), password=dotenv.get('PASSWORD'), dbname=dotenv.get('DATABASE'))
def test_get_int(self): """ Test return value is of the correct type <int> """ self.assertIs(type(dotenv.get('INT')), int) self.assertEqual(dotenv.get('INT'), 12345)
def test_get_default_value(self): """ Test return value of default value """ self.assertEqual( dotenv.get('MISSING_KEY', 'default_value'), 'default_value' )
def make_api_request(query): api_url = dotenv.get('API_URL_ENDPOINT') endpoint = '{}?query={}'.format(api_url, query) headers = {'X-TavernaToken': dotenv.get('X-TAVERNATOKEN')} return requests.post(endpoint, headers=headers).json()
class Config: dotenv.load("./.env") AZURE_TA_KEY = dotenv.get("AZURE_TA_KEY") AZURE_TA_ENDPOINT = dotenv.get("AZURE_TA_ENDPOINT") NOMBRES_ENCARGADOS_ORG = ["Aldo Madero"] HORA_EJECUCION = dotenv.get("HORA_EJECUCION") BAN_SOCIEDADES = obtener_avisos_excluidos("AVISOS_EXCLUIDOS.TXT") AZURE_LIMITE_CARACTERES = dotenv.get("AZURE_LIMITE_CARACTERES") PATRONES_RAZON_SOCIAL = [ r"SOCIEDADES\s.*\"(.*)\"", r'SOCIEDADES\s\/\s.*\"(.*)\" \(CONSTITUCIÓN\)"*', r'"(.*) \(CONSTITUCIÓN\)\"*', r"SOCIEDADES\s\/\s(.*)\(CONSTITUCIÓN\)", r'SOCIEDADES\s\/\s.*\"(.*)\" \(CONSTITUCIN\)"*', r'"(.*) \(CONSTITUCIN\)\"*', r"SOCIEDADES\s\/\s(.*)\(CONSTITUCIN\)", r'SOCIEDADES\s\/\s"(.*)\"', r"SOCIEDADES\s\/\s(.*)\.$", r"SOCIEDADES\s\/\s(.*)", r'"(.*)"', ] PATRONES_RAZON_SOCIAL_AVISO = [ r"\"(.*)\"", r"\“(.*)\”", ] URLS = { "base_url": "https://boletin.tucuman.gov.ar/", "tabla_url": "https://boletin.tucuman.gov.ar/tabla", } HEADERS = { "X-Requested-With": "XMLHttpRequest", "User-Agent": crear_random_agent(), "Referer": URLS["tabla_url"], } CATEGORIAS_SOLICITADAS = ["SOCIEDADES", "ASAMBLEAS", "AVISOS"] REGEX_HEADER_0 = dotenv.get("REGEX_HEAD_0") REGEX_HEADER_1 = dotenv.get("REGEX_HEAD_1") REGEX_HEADER_2 = dotenv.get("REGEX_HEAD_2") REGEX_HEADER_3 = dotenv.get("REGEX_HEAD_3") OFFSET_INCREMENTO = dotenv.get("OFFSET_INCREMENTO") PAYLOAD = { "tiposinstrumentos": dotenv.get("TIPOS_INSTRUMENTOS"), "TiposJudiciales": dotenv.get("TIPOS_JUDICIALES"), "TiposComunes": dotenv.get("TIPOS_COMUNES"), "fechaboletin1": dotenv.get("FECHA_1"), "fechaboletin2": dotenv.get("FECHA_2"), "offset": dotenv.get("OFFSET"), "Submit": dotenv.get("SUBMIT"), } DB_DOCKER = { "DB_HOST": dotenv.get("DB_HOST_DOCKER"), "DB_NAME": dotenv.get("DB_NAME_DOCKER", default=""), "DB_USER": dotenv.get("DB_USER_DOCKER"), "DB_PASS": str(dotenv.get("DB_PASS_DOCKER")), "DB_PORT": dotenv.get("DB_PORT_DOCKER", default="3306"), } DB_PROD = { "DB_HOST": dotenv.get("DB_HOST_PROD"), "DB_NAME": dotenv.get("DB_NAME_PROD", default=""), "DB_USER": dotenv.get("DB_USER_PROD"), "DB_PASS": str(dotenv.get("DB_PASS_PROD")), } DB_MONGO = dotenv.get("DB_MONGO") MAIL = { "MAIL_DESTINO": dotenv.get("MAIL_DESTINO"), "MAIL_USUARIO": dotenv.get("MAIL_USUARIO"), "MAIL_ASUNTO": dotenv.get("MAIL_ASUNTO"), "MAIL_PASS": dotenv.get("MAIL_PASS"), }
help= 'Supersede constants in code from some filename. Script uses .env as default anyways.' ) global args args = parser.parse_args() env_path = Path('.') / args.config_file dotenv.load(env_path) global DUR_THRESH global SILENCE_THRESH global TEST_COUNT global ALPHA_CUTOFF global ANOTHER_CUTOFF DUR_THRESH = float(dotenv.get("DUR_THRESH", 1.2)) SILENCE_THRESH = float(dotenv.get("SILENCE_THRESH", 1e-02)) TEST_COUNT = int(dotenv.get("TEST_COUNT", 3)) ALPHA_CUTOFF = float(dotenv.get("ALPHA_CUTOFF", 0.1)) ANOTHER_CUTOFF = float(dotenv.get("ANOTHER_CUTOFF", 0.3)) # imported and explained (sort of, kinda, I hope) else: # "shortest distinguishable sound interval is 1.2ms" (Irwin & Purdy, 1982) DUR_THRESH = 1.2 # one more for differentiating between signal and silence SILENCE_THRESH = 1e-02 # this will be doubled, mind you TEST_COUNT = 3
#!/usr/bin/python # -*- coding: utf-8 -*- import os import dotenv dotenv.load() or dotenv.load('.env') DEV_EMAIL = dotenv.get('DEV_EMAIL', default=None) DEBUG = dotenv.get('DEBUG', default=False) HOST = dotenv.get('HOST') HTTPS = dotenv.get('HTTPS', default=True) PROJECTPATH = dotenv.get('PROJECTPATH') FLASK_SECRET_KEY = dotenv.get('FLASK_SECRET_KEY') APP_LOG_FILENAME = os.path.join(PROJECTPATH, 'app.log') SQLALCHEMY_DATABASE_URI = dotenv.get('DATABASE_URL') SENDGRID_API_KEY = dotenv.get('SENDGRID_API_KEY') FULLCONTACT_KEY = dotenv.get('FULLCONTACT_KEY') TEMPLATE_ROOT = os.path.join(PROJECTPATH, 'templates') STATIC_ROOT = os.path.join(PROJECTPATH, 'static') RECAPTCHA_SITE_KEY = dotenv.get('RECAPTCHA_SITE_KEY')
def get_files(): conn = S3Connection(dotenv.get('AWS_ACCESS_KEY'), dotenv.get('AWS_SECRET_KEY')) bucket = conn.get_bucket(dotenv.get('S3_BUCKET')) for key in bucket.list(): print key.name.encode('utf-8') return 'success'
from twilio.rest import TwilioRestClient import dotenv #LOAD THE ENV FILE dotenv.load() ACCOUNT_SID = dotenv.get('ACCOUNT_SID', default=None) AUTH_TOKEN = dotenv.get('AUTH_TOKEN', default=None) def chineseNewYear(): # put your own credentials here global ACCOUNT_SID global AUTH_TOKEN client = TwilioRestClient(ACCOUNT_SID, AUTH_TOKEN) dict = {"me":"+65 1234 1234" }; for key, value in dict.iteritems(): client.messages.create( to="".join(value.split()), from_="ZhenJie", body="Dear " + key + ", hope all your New Year dreams come true! " + "I wish you good health, wealth and luck for the forthcoming year of the Monkey!", ) def goodFriday(): global ACCOUNT_SID global AUTH_TOKEN client = TwilioRestClient(ACCOUNT_SID, AUTH_TOKEN)
import dotenv from common.utils import render dotenv.load() API_TOKEN = dotenv.get('SLACKBOT_API_TOKEN') DEFAULT_REPLY = render('help_response.j2') ERRORS_TO = dotenv.get('ERRORS_CHANNEL') PLUGINS = [ 'plugins' ]
"""Define settings using values of environment variables.""" import dotenv dotenv.load() if dotenv.get('HEROKU'): from .production import * else: from .development import *
import dotenv from flask.ext.script import Manager from flask.ext.script import Server from knotmarker import app from knotmarker.commands import Grab, Grab2 from knotmarker.commands import TypesImporter from knotmarker.commands import AddSize dotenv.load() manager = Manager(app) DEBUG = dotenv.get('KNOTMARKER_DEBUG', False) manager.add_command( "runserver", Server(use_debugger=DEBUG, use_reloader=DEBUG, host='0.0.0.0')) manager.add_command("grab", Grab()) manager.add_command("grab2", Grab2()) manager.add_command("import_types", TypesImporter()) manager.add_command("add_size", AddSize()) if __name__ == "__main__": manager.run()
def test_get_string(self): """ Test return value is of the correct type <string> """ self.assertIs(type(dotenv.get('string')), str) self.assertEqual('This is a string', dotenv.get('string'))
import os import dotenv from django.contrib.admin import AdminSite dotenv.load() # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/1.9/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = dotenv.get('SECRET_KEY') # Application definition PREREQ_APPS = [ 'suit', 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'graphene_django', ] PROJECT_APPS = [ 'app.api.apps.ApiConfig',
import os import dotenv from django.contrib.admin import AdminSite dotenv.load() # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname( os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/1.9/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = dotenv.get('SECRET_KEY') # Application definition PREREQ_APPS = [ 'suit', 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'graphene_django', ] PROJECT_APPS = [ 'app.api.apps.ApiConfig',
"""Settings package initialization.""" import dotenv dotenv.load() # Ensure development settings are not used in testing and production: if dotenv.get('ENVIRONMENT') == 'HEROKU': from .production import * elif dotenv.get('ENVIRONMENT') == 'TRAVIS': from .testing import * else: from .local import *
if is_lazy_string(o): return str(o) return BaseEncoder.default(self, o) app.json_encoder = JSONEncoder app.config['BABEL_DEFAULT_LOCALE'] = 'ru' babel = Babel(app) @babel.localeselector def get_locale(): return 'ru' app.config['MAIL_SERVER'] = dotenv.get( 'KNOTMARKER_MAIL_SERVER', 'smtp.gmail.com') app.config['MAIL_PORT'] = 465 app.config['MAIL_USE_SSL'] = True app.config['MAIL_USERNAME'] = dotenv.get( 'KNOTMARKER_MAIL_USERNAME', '*****@*****.**') app.config['MAIL_PASSWORD'] = dotenv.get('KNOTMARKER_MAIL_PASSWORD') mail = Mail(app) app.config['MONGODB_DB'] = dotenv.get('KNOTMARKER_MONGODB_DB', 'knotmarker') app.config['MONGODB_HOST'] = dotenv.get('KNOTMARKER_MONGODB_HOST', 'localhost') app.config['MONGODB_PORT'] = dotenv.get('KNOTMARKER_MONGODB_PORT', 27017) app.config["SECRET_KEY"] = bytes(dotenv.get('KNOTMARKER_SECRET_KEY'), 'utf8') app.config["SECURITY_REGISTERABLE"] = True app.config["SECURITY_CONFIRMABLE"] = True app.config["SECURITY_RECOVERABLE"] = True
import dotenv from flask.ext.script import Manager from flask.ext.script import Server from knotmarker import app from knotmarker.commands import Grab, Grab2 from knotmarker.commands import TypesImporter from knotmarker.commands import AddSize dotenv.load() manager = Manager(app) DEBUG = dotenv.get('KNOTMARKER_DEBUG', False) manager.add_command("runserver", Server( use_debugger=DEBUG, use_reloader=DEBUG, host='0.0.0.0') ) manager.add_command("grab", Grab()) manager.add_command("grab2", Grab2()) manager.add_command("import_types", TypesImporter()) manager.add_command("add_size", AddSize()) if __name__ == "__main__": manager.run()
import dotenv from tweepy.api import API from tweepy.auth import OAuthHandler from tweepy.streaming import Stream from responsebot.handlers.tweepy_base_handler import TweepyBaseTweetHandler from responsebot.listeners.tweepy_wrapper_listener import TweepyListener dotenv.load() API_KEY = dotenv.get('API_KEY') API_SECRET = dotenv.get('API_SECRET') ACCESS_TOKEN = dotenv.get('ACCESS_TOKEN') ACCESS_SECRET = dotenv.get('ACCESS_SECRET') class PrintTweetHandler(TweepyBaseTweetHandler): def on_tweet(self, tweet): print(""" ========= User: {name} Content: {content} ========= """.format( name=tweet.user.screen_name, content=tweet.text )) def authenticate():
"""Settings package initialization.""" import dotenv dotenv.load() # Ensure development settings are not used in testing and production: if dotenv.get('ENVIRONMENT') == 'PRODUCTION': from .production import * elif dotenv.get('ENVIRONMENT') == 'TRAVIS': from .testing import * else: from .local import *