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