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 *
