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)
def test_load_filepath_missing(self): """ Test case where no filepath has been enter by the user. """ with mock.patch('os.path.exists') as mock_pathexists: mock_pathexists.return_value = False response = dotenv.load() self.assertFalse(response) with mock.patch('os.path.exists') as mock_pathexists, \ mock.patch('dotenv._get_line_') as mock_line, \ mock.patch('os.environ') as mock_environ: mock_line.return_value = [ ('KEY1', 'value1'), ('KEY2', 'value2') ] mock_pathexists.return_value = True _environ = {} def _setdetault(key, value): """ Set key->value """ _environ.setdefault(key, value) mock_environ.setdefault.side_effect = _setdetault response = dotenv.load() self.assertTrue(response)
def connect_to_stream(): """ Environment Description fxTrade (Live) The live (real money) environment fxTrade Practice (Demo) The demo (simulated money) environment """ dotenv.load() domainDict = { 'live' : 'stream-fxtrade.oanda.com', 'demo' : 'stream-fxpractice.oanda.com' } # Replace the following variables with your personal values environment = "demo" # Replace this 'live' if you wish to connect to the live environment domain = domainDict[environment] access_token = os.environ.get('OANDA_TOKEN') account_id = os.environ.get('OANDA_ACCOUNT') instruments = 'USD_JPY,EUR_USD,AUD_USD,EUR_GBP,USD_CAD,USD_CHF,USD_MXN,USD_TRY,USD_CNH,NZD_USD' try: s = requests.Session() url = "https://" + domain + "/v1/prices" headers = {'Authorization' : 'Bearer ' + access_token, # 'X-Accept-Datetime-Format' : 'unix' } params = {'instruments' : instruments, 'accountId' : account_id} req = requests.Request('GET', url, headers = headers, params = params) pre = req.prepare() resp = s.send(pre, stream = True, verify = True) return resp except Exception as e: s.close() print("Caught exception when connecting to stream\n" + str(e))
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 _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 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 __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 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 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): logging.basicConfig(level=logging.INFO) dotenv.load() override_with_cli_args() try: host = os.environ[HOST] port = os.environ[PORT] log_level = os.environ[LOG_LEVEL] logging.basicConfig(level=log_level) self.host = host self.port = port except KeyError as err: default_logger.error( "Can`t configure server from environment-configuration. %r", err)
def load_env(): env_path = os.path.abspath('.') env_file = env_path + "/.env" if not os.path.isfile(env_file): shutil.copy('.env.example', '.env') return dotenv.load(env_file)
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 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 test_load(self, mock_line): """ Test loading data into os.environ from file content """ _environ = {} def _setdetault(key, value): """ Set key->value """ _environ.setdefault(key, value) with mock.patch('os.path.exists') as mock_pathexists, \ mock.patch('os.environ') as mock_environ: mock_line.return_value = [ ('KEY11', 'value1'), ('KEY22', 'value2') ] mock_pathexists.return_value = True mock_environ.setdefault.side_effect = _setdetault dotenv.load('/file/path') mock_pathexists.assert_called_once_with('/file/path') self.assertEqual(_environ['KEY11'], 'value1') self.assertEqual(_environ['KEY22'], 'value2')
#!/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')
const=True, default=False, help='Print debug info') parser.add_argument( '--config', dest='config_file', action='store', default='.env', 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:
For the full list of settings and their values, see https://docs.djangoproject.com/en/1.8/ref/settings/ """ # Build paths inside the project like this: os.path.join(BASE_DIR, ...) import os import sys import dotenv from datetime import timedelta BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) dotenv_path = os.path.normpath(os.getcwd() + os.sep + os.pardir + '/.env') dotenv.load(dotenv_path) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/1.8/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = os.environ.get('SECRET_KEY') # SECURITY WARNING: don't run with debug turned on in production! DEBUG = True ALLOWED_HOSTS = [] # Application definition
#!/usr/local/bin/python import pandas as pd import redis import sys from os.path import join, dirname import os import dotenv import numpy as np from sklearn.linear_model import LinearRegression dotenv.load(join(dirname(__file__), '../../.env')) r = redis.StrictRedis(host=os.environ.get('REDIS_HOST'), port=os.environ.get('REDIS_PORT'), db=0) book = r.get('laravel:tempbook') if sys.version_info[0] < 3: from StringIO import StringIO else: from io import StringIO TDATA = StringIO(book) df = pd.read_csv(TDATA) to_forecast = df.close.values dates = df.id.values # mean absolute percentage error def mape(ypred, ytrue): """ returns the mean absolute percentage error """ idx = ytrue != 0.0
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"), }
import os import dotenv dotenv.load() # remove in deployment FIREBASE_CONFIG = { "apiKey": os.environ.get("FIREBASE_API_KEY"), "authDomain": os.environ.get("FIREBASE_AUTH_DOMAIN"), "databaseURL": os.environ.get("FIREBASE_DATABASE_URL"), "storageBucket": os.environ.get("FIREBASE_STORAGE_BUCKET"), } class Globals: WEBSOCKET = None
"""Application configuration.""" import json import logging import os import dotenv from sqlalchemy.pool import NullPool from sqlalchemy.pool import StaticPool # Load environment variables from a .env file dotenv.load('/home/spring/PycharmProjects/ows-asset-bulk-script/.env') pt = os.getcwd() test = os.environ.get('TEST') # Service information SERVICE_NAME = 'ows-asset-bulk-script' SERVICE_VERSION = '0.0.1' # Production environment PROD_ENVIRONMENT = 'prod' DEV_ENVIRONMENT = 'dev' QA_ENVIRONMENT = 'qa' TEST_ENVIRONMENT = 'test' ENVIRONMENT = os.environ.get('Environment', DEV_ENVIRONMENT) # Errors and loggers SENTRY = os.environ.get('SENTRY_DSN')
# `8' `YooP8 8 8 8 8YooP' 8 8 `Yooo' `YooP' `Yooo' 8 `YP' `Yooo' 8 8oooP' `YooP' 8 # :::..::::.....:..:..:..8 ....::....:::::.....::::.....::.....:..::::::...:::.....:..:::::::......::.....:::. # :::::::::::::::::::::::8 ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: # :::::::::::::::::::::::..::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: import discord, asyncio, dotenv from discord.ext import commands from cogs import Moderation, Automation, ServerRole, Tools from keep_alive import keep_alive ############################################################################################################## ### Initial stuff ############################################################################################ ############################################################################################################## # Settings the bot's token dotenv.load("config.env") TOKEN = dotenv.get("BOT_TOKEN") # Setting the bot's command prefix client = commands.Bot(command_prefix = ".") # Removing the standard 'help' command client.remove_command("help") #Loading Cogs: client.load_extension("cogs.MessageHandler") #Message and Command handling client.load_extension("cogs.Moderation") #Admin commands client.load_extension("cogs.Automation") #Listeners client.load_extension("cogs.ServerRole") #Role command client.load_extension("cogs.Tools") #For tools like .ping client.load_extension("cogs.OnReady") #on_ready event
# Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__)) # Static files (CSS, JavaScript, Images) # https://docs.djangoproject.com/en/1.9/howto/static-files/ STATIC_ROOT = os.path.join(PROJECT_ROOT, 'staticfiles') STATIC_URL = '/static/' # Extra places for collectstatic to find static files. STATICFILES_DIRS = (os.path.join(PROJECT_ROOT, 'static'), ) dotenv_path = os.path.join(BASE_DIR, '.env') load(dotenv_path) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/1.11/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = '%8svmm%)4=so1o$9t=a3mgw4we_pmsbt_ne8ze*o$1@h!==qc!' # SECURITY WARNING: don't run with debug turned on in production! DEBUG = True ALLOWED_HOSTS = [] redis_host = os.environ.get('REDIS_HOST', 'localhost') # Channel layer definitions
async def on_ready(self): # Setting the channel to send the email to channel = self.client.get_channel(564783779474833431) # Getting the .env file dotenv.load() # Setting the email account login host = dotenv.get("IMAP_HOST") username = dotenv.get("IMAP_ACC") password = dotenv.get("IMAP_PASS") while True: # Setting the IMAP server mail = imaplib.IMAP4_SSL(host) # Logging in mail.login(username, password) # Selecting the inbox mail.select("INBOX") result, data = mail.uid("search", None, "ALL") inbox_item_list = data[0].split() # Splitting mail IDs last_mail_uid_str = data[0].decode('UTF-8').split(" ") last_mail_uid = int(last_mail_uid_str[-1]) # Checking if ID was already processed lastfile = open("last.txt", 'r') last_edited_uid = int(lastfile.read()) if last_mail_uid == last_edited_uid: # If already processed: print("[Mail] No updates ({}".format(time.strftime("%H")) + "h)") else: # If new: print("{}, {}".format(last_mail_uid, last_edited_uid)) diff = last_mail_uid - last_edited_uid while not (diff == 0): current_item = inbox_item_list[(diff - (2 * diff))] result2, email_data = mail.uid("fetch", current_item, "(RFC822)") raw_email = email_data[0][1].decode("utf-8") email_message = email.message_from_string(raw_email) # Get the content of the email and remove unnecessary stuff mail_body = email_message.get_payload() mail_body = mail_body.replace("\r", "") mail_body = mail_body.replace("\n\n", "") # The data is split by §§ contentlist = mail_body.split("§§") # Handling emails which arent encoded correctly if not (email_message["Content-Transfer-Encoding"] == "8bit"): await channel.send( "I've received an email but don't know how to handle it. Please check it manually: {}" .format(email_message["Subject"].replace("_", " "))) # Staff applications elif email_message["Subject"].lower() == "staff_apply": await channel.send( "**STAFF APPLICATION** @here\n\n__Name:__ " + contentlist[0] + " (" + contentlist[1] + " y/o, " + contentlist[2] + ")\n__Minecraft Username:__ ``" + contentlist[3] + "`` __Discord#Tag:__ ``" + contentlist[4] + "`` __Email:__ ``" + contentlist[5] + "``\n** **") await channel.send( "__◆ Do you have experience as staff?__\n" + contentlist[6]) await channel.send( "__◆ Why do you want to be staff?__\n" + contentlist[7]) await channel.send( "__◆ Why should you be chosen instead of someone else?__\n" + contentlist[8] + "\n** **") await channel.send( "__◆ Do you have any issues with the current staff team?__ \n" + contentlist[9] + "\n__◆ How many hours per week can you contribute?__ \n" + contentlist[10] + " hours") # Ban appeals elif email_message["Subject"].lower() == "ban_appeal": await channel.send( "**BAN APPEAL** @here\n\n__Minecraft Username:__ " + contentlist[0] + " __Contact:__ " + contentlist[1] + "\n\n__◆ More about your ban__\n" + contentlist[2] + "\n__◆ Why should you be unbanned?__\n" + contentlist[3]) # Player reports elif email_message["Subject"].lower() == "player_report": await channel.send( "**PLAYER REPORT** @here\n\n__Report by:__ ``" + contentlist[0] + "`` __Contact:__ ``" + contentlist[1] + "``\n\n" + contentlist[2]) # Unknown/Error else: await channel.send( "I've received an email but don't know how to handle it. {}:" .format(email_message["From"]) + email_message.get_payload()) diff = diff - 1 # Updating last processed ID lastfile.close() lastfile = open("last.txt", "w") lastfile.write(last_mail_uid_str[-1]) lastfile.close() # Sleeping for one hour await asyncio.sleep(3600)
import os from dotenv import load if not os.getenv("TEST_RUN", False): load() def _get_devices(): device_list = os.getenv("DEVICES", "") device_list = device_list.split(",") if not all(len(device) == 17 for device in device_list): raise ValueError("Invalid MAC address") return device_list def _get_bluetooth_devices(): device_list = os.getenv("BLUETOOTH_DEVICES", "") device_list = device_list.split(",") wifi_addresses = [] bt_addresses = [] for device in device_list: splitted = device.split(";") wifi_addresses.append(splitted[0]) bt_addresses.append(splitted[1]) return {wifi: bt for wifi, bt in zip(wifi_addresses, bt_addresses)} def _get_arrive_lights(): return os.getenv("ARRIVE_LIGHTS", "").split(",")
import matplotlib matplotlib.use('Agg') import matplotlib.pyplot as plt SECONDS_RESOLUTION = 10 def get_env_var(env_var): if env_var not in os.environ: raise KeyError('No tokens set under {} in .env file'.format(env_var)) return str(os.environ[env_var]) dotenv.load() # Make sure we load in the .env file CONSUMER_KEY = get_env_var('CONSUMER_KEY') CONSUMER_SECRET = get_env_var('CONSUMER_SECRET') ACCESS_KEY = get_env_var('ACCESS_KEY') ACCESS_SECRET = get_env_var('ACCESS_SECRET') def parse_filename_as_datetime(filename): secs = filename.split('/')[-1].split('.')[0] secs = int(secs) return datetime.datetime.fromtimestamp(secs) def get_counts_by_day_and_hour(target_files): # From this list of files, use the filenames to determine # which day-hour combo has the most datapoints associated
from dotenv import load import os load("../../.env") ENV = os.environ # Use like: # # from env import ENV # with open("{}/CaseDocuments/All_FT/{}".format(ENV["DATASET_PATH"], case_filename)) as f:
import os import dotenv import requests # http://www.octranspo.com/developers/documentation#method-GTFS # https://developers.google.com/transit/gtfs/reference/#tripstxt # Adjustment Age # AdjustmentAge indicates the last time (in minutes and adjusted in whole and fractional minutes) when the GPS data available for the bus was used to determine the AdjustedScheduleTime. The higher the number the less reliable the AdjustedScheduleTime is. # If the AdjustmentAge is a negative value, it indicates that the AdjustedScheduleTime contains the planned scheduled time. assert dotenv.load(__file__.replace('octranspo/oc_api.py', '.env')) def route_summary_for_stop(stop_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/GetRouteSummaryForStop', data={ "appID": dotenv.get('APP_ID'), "apiKey": dotenv.get('API_KEY'), "stopNo": stop_no, "format": "json" }).json() def next_trips_all_routes(stop_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/GetNextTripsForStopAllRoutes',
import os import client as client import dotenv dotenv.load() if __name__ == '__main__': clnt = client.Client(os.getenv('HOST'), int(os.getenv('SERVER_PORT'))) command = clnt.run()
#!/usr/bin/env python3 import sys import time import dotenv dotenv.load('../.env') import json from kafka import KafkaConsumer import mysql.connector class logs: 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 decode_knx_infos(self, content): if all(item in content.keys() for item in ['kind', 'bloc', 'floor', 'reason', 'value']): kind = content['kind'] bloc = content['bloc'] floor = content['floor'] reason = content['reason'] value = content['value']
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():
import wave import dotenv dotenv.load('resources/challenge.env') SSTV_FILE = dotenv.get('SSTV_FILE') or 'flag.wav' SONG_FILE = dotenv.get('SONG_FILE') or 'resources/nirvana.wav' CHALLENGE_FILE = dotenv.get('CHALLENGE_FILE') or 'challenge.wav' # Read wave song audio file with wave.open(SONG_FILE, mode='rb') as song: print(f"Reading \"{SONG_FILE}\"") # Read wave sstv audio file with wave.open(SSTV_FILE, mode='rb') as sstv_audio: print(f"Reading \"{SSTV_FILE}\"") # Read frames and convert to byte array song_bytes = bytearray(list(song.readframes(song.getnframes()))) # Read frames from messge and convert to list of integers sstv_list_of_bytes = list(sstv_audio.readframes(sstv_audio.getnframes())) # Prepare string that will contain bits from the list above sstv_binary_string = '' # Fill string with bits from list: [0b1,0b0] -> '0000000100000000' for integer in sstv_list_of_bytes: sstv_binary_string = sstv_binary_string + bin(integer).lstrip('0b').ljust(8, '0') # Shorten song so it matches length of sstv message song_bytes = song_bytes[:len(sstv_binary_string)]