def test_dotenv_nonempty_selfreferential_interpolation():
stream = StringIO(u'some_path="${some_path}:a/b/c"\n')
stream.seek(0)
assert u'some_path' not in os.environ
with restore_os_environ():
os.environ[u'some_path'] = u'x/y/z'
parsed_dict = dotenv_values(stream=stream)
assert {u'some_path': u'x/y/z:a/b/c'} == parsed_dict
from time import sleep
from typing import Dict, Generator, List
import luigi
from luigi.contrib.mongodb import MongoTarget
from pymongo import MongoClient
import pandas as pd
from dotenv import dotenv_values
import os
import json
import hashlib
import sys
from app.utils.factorutils import op, intersectCode
config = dotenv_values('.env')
class MongoCollectionTarget(MongoTarget):
""" Target for existing collection """
def __init__(self, mongo_client: MongoClient, index: str,
collection: str) -> None:
super(MongoCollectionTarget, self).__init__(mongo_client, index,
collection)
def exists(self) -> bool:
"""
Test if target has been run
Target is considered run if the targeted collection exists in the database
"""
return self.read()
def read(self) -> bool:
import requests
from bs4 import BeautifulSoup
import logging
import dotenv
import datetime
import json
import time
logging.basicConfig(filename='Zalandolog.log',
filemode='a',
format='%(asctime)s - %(name)s - %(message)s',
level=logging.DEBUG)
CONFIG = dotenv.dotenv_values(dotenv_path='.env')
class ZalandoMonitor:
def __init__(self, webhook, proxy):
self.webhook = webhook
if proxy is None:
self.proxy = {}
else:
self.proxy = {'https': f'https://{proxy}'}
self.headers = {
'user-agent':
'ozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X) AppleWebKit/605.1.15 ('
'KHTML, like Gecko) Version/13.0.3 Mobile/15E148 Safari/604.1',
'accept':
'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,'
'image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9',
'accept-language':
'en-GB,en-US;q=0.9,en;q=0.8'
import json
from bs4 import BeautifulSoup
import urllib3
import time
import logging
import dotenv
from random_user_agent.user_agent import UserAgent
from random_user_agent.params import SoftwareName, HardwareType
from fp.fp import FreeProxy
logging.basicConfig(filename='Footlockerlog.log', filemode='a', format='%(asctime)s - %(name)s - %(message)s', level=logging.DEBUG)
software_names = [SoftwareName.CHROME.value]
hardware_type = [HardwareType.MOBILE__PHONE]
user_agent_rotator = UserAgent(software_names=software_names, hardware_type=hardware_type)
CONFIG = dotenv.dotenv_values()
proxyObject = FreeProxy(country_id=['CA'], rand=True)
INSTOCK = []
def discord_webhook(product_item):
"""
Sends a Discord webhook notification to the specified webhook URL
:param product_item: An array of the product's details
:return: None
"""
data = {}
data["username"] = CONFIG['USERNAME']
data["avatar_url"] = CONFIG['AVATAR_URL']
from dotenv import dotenv_values
import logging
from devman_bot import bot_start
if __name__ == '__main__':
dotenv_dict = dotenv_values()
token_telegram_bot = dotenv_dict['token_telegram_bot']
chat_id_telegram = dotenv_dict['chat_id_telegram']
token_devman = dotenv_dict['token_devman']
logger = logging.getLogger('Bot-logger')
logger.setLevel(logging.INFO)
bot_start(token_telegram_bot, chat_id_telegram, token_devman, logger)
def __init__(self):
self.config = dotenv_values(".env")
self.xml_path = self.config["XML_PATH"]
self.tree = etree.parse(self.xml_path)
self.forms = self.build_forms()
# std:
import os
import sys
# pip-ext:
import waitress
import dotenv
# pip-int:
# n/a
# loc:
# DELAYED
assert len(sys.argv) == 2
envFilename = sys.argv[1]
for (key, value) in dotenv.dotenv_values(envFilename).items():
if key not in os.environ:
os.environ[key] = value
# loc:
from constants import K
import utils
from mongo import db
import userMod
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
import tweepy
from tqdm import tqdm
# dataset can be downloaded from https://data.mendeley.com/datasets/rxwfb3tysd/2
# download the subtask1.zip file to get the correct files.
# todo: create .env file with your credentials with format
# consumer_key=XXXX
# consumer_key_secret=XXXX
# access_token=XXXX
# access_token_secret=XXXX
# or just copy paste them into the variables
# Get credentials from .env file
env = dotenv.dotenv_values(os.path.join('..', '.env'))
consumer_key = env.get('consumer_key')
consumer_key_secret = env.get('consumer_key_secret')
access_token = env.get('access_token')
access_token_secret = env.get('access_token_secret')
# initialize Twitter API
auth = tweepy.OAuthHandler(consumer_key, consumer_key_secret)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth)
def create_data_file(input_filepath, output_filepath):
input_file = open(input_filepath, encoding='utf8')
output_file = open(output_filepath, 'a', encoding='utf8')
def current_dotenv_values(self):
"Values currently stored in the dotenv as a dict"
return dotenv.dotenv_values(self.dotenv)
import random
import dotenv
import aiogram
import tinydb
from aiogram import types
from aiogram.utils import executor
from loguru import logger
from tinydb import Query
from tinydb.operations import set as set_
import parse
env = dotenv.dotenv_values()
db = tinydb.TinyDB("botdb.json")
bot = aiogram.Bot(env["BOT_TOKEN"], proxy=env["PROXY"])
dp = aiogram.Dispatcher(bot)
HELP_TEXT = """Мои комманды:
`/add <имя>` - добавляет ученика в список
`/list` - показывает список учеников
`/edit "<старое_имя>" "<новое_имя>"` - изменяет имя ученика
`/delete <имя>` - удаляет ученика из списка
`/choose` - выдает случайный список учеников
"""
@dp.message_handler(commands=["help", "start"])
async def help_(message: types.Message):
"""
Given the CouchDB Docker container, still some settings need to be made manually
after starting the Docker container. This helps to reduce the amount of logged
messages of the CouchDB Docker container.
"""
import warnings
import requests
import dotenv
warnings.filterwarnings('once', message='Unverified HTTPS request')
config = dotenv.dotenv_values("couchdb_credentials.env")
username = config["COUCHDB_USER"]
password = config["COUCHDB_PASSWORD"]
server_url = config["COUCHDB_URL"] # Assume Docker host to be localhost
# Create CouchDB system database '_users'
# See https://github.com/apache/couchdb-docker#no-system-databases-until-the-installation-is-finalized
# for details.
response = requests.put(f"https://{server_url}/_users",
auth=requests.auth.HTTPBasicAuth(username, password),
verify=False)
assert response.status_code in (201, 202), \
f"Creation of database '_users' failed with status code {response.status_code}, maybe it already exists?"
#!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys
from io import StringIO
from dotenv import dotenv_values
filelike = StringIO('SPAM=EGGS\n')
filelike.seek(0)
parsed = dotenv_values(stream=filelike)
def main():
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'bookmarks.settings')
try:
from django.core.management import execute_from_command_line
except ImportError as exc:
raise ImportError(
"Couldn't import Django. Are you sure it's installed and "
"available on your PYTHONPATH environment variable? Did you "
"forget to activate a virtual environment?") from exc
execute_from_command_line(sys.argv)
if __name__ == '__main__':
main()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import dotenv
TELEGRAM_TOKEN="TELEGRAM_TOKEN"
TELEGRAM_CONTROL_GROUP_ID="TELEGRAM_CONTROL_GROUP_ID"
STORAGE_DIR="STORAGE_DIR"
MQTT_HOST="MQTT_HOST"
MQTT_PORT="MQTT_PORT"
MQTT_TOPIC_CONTROL="MQTT_TOPIC_CONTROL"
MQTT_TOPIC_REQUEST="MQTT_TOPIC_REQUEST"
MQTT_TOPIC_RESPONSE="MQTT_TOPIC_RESPONSE"
ACCUWEATHER_API_KEY='ACCUWEATHER_API_KEY'
ACCUWEATHER_LOCATION_KEY='ACCUWEATHER_LOCATION_KEY'
scriptDir = sys.path[0] #os.path.dirname(os.path.realpath(__file__))
envPath = scriptDir + '/../.env'
env = dotenv.dotenv_values(dotenv_path=envPath)
outputDir = env[STORAGE_DIR]
outputDir = outputDir if outputDir.startswith('/') else (scriptDir + '/' + outputDir)
fontsDir = scriptDir + '/../resources/fonts/'
iconsDir = scriptDir + '/../resources/icons/'
def get_variables_from_dotenv_file(self):
DJANGO_ENVIRONMENT = os.getenv(self.django_environment_var_name) \
if os.getenv(self.django_environment_var_name) is not None else ''
env_path = Path('EnvVars/%s.env' % (DJANGO_ENVIRONMENT))
return dotenv_values(dotenv_path=env_path, verbose=True)
import time
from datetime import datetime
from dotenv import dotenv_values
from sqlalchemy import create_engine, text, MetaData, Table, ForeignKey, func, or_, and_
from sqlalchemy.ext.automap import automap_base
from sqlalchemy.orm import sessionmaker, relationship
import pandas as pd
from tabulate import tabulate
# docs
# https://docs.sqlalchemy.org/en/14/orm/tutorial.html#querying
# Performance: https://docs.sqlalchemy.org/en/14/faq/performance.html
try:
ENV_CONFIG = dotenv_values(
".env") # config = {"USER": "******", "EMAIL": "*****@*****.**"}
except ImportError as e:
raise ImportError(
'python-dotenv is not installed, run `pip install python-dotenv`')
def output_table(titles=[], rows=[]):
"""
output_tables(['names', 'weights', 'costs', 'unit_costs'], [[xx, xx], [xx, xx]])
"""
data = [titles] + list(zip(*rows))
for i, d in enumerate(data):
line = '|'.join(str(x).ljust(12) for x in d)
print(line)
if i == 0:
from django.shortcuts import render
from django.views.decorators.http import require_http_methods
from django.views.decorators.csrf import csrf_exempt
from django.http import JsonResponse
from json import loads
from api.models import Text, Sentiment, Entity
import requests
from dotenv import dotenv_values
# Configuration variables to make request to text API
URL = 'https://aylien-text.p.rapidapi.com/'
ENV = dotenv_values('.env')
HEADERS = {
'x-rapidapi-key': ENV.get('RAPID_API_KEY'),
'x-rapidapi-host': "aylien-text.p.rapidapi.com"
}
def json_body(body=b''):
'''This method parses the body content to json content like'''
try:
body = body.decode('utf-8')
json_body = loads(body)
except Exception as err:
return {
'err': err
}
return json_body
@csrf_exempt
def test_dotenv_empty_selfreferential_interpolation():
stream = StringIO(u'some_path="${some_path}:a/b/c"\n')
stream.seek(0)
assert u'some_path' not in os.environ
parsed_dict = dotenv_values(stream=stream)
assert {u'some_path': u':a/b/c'} == parsed_dict
def __init__(self):
self.SECRETS = dict(dotenv_values())
def __init__(self):
for k, v in dotenv_values(".settings").items():
setattr(self, k, v)
from urllib.request import urlopen
import json
import cloudinary.api
import cloudinary.uploader
import time
import traceback
from dotenv import dotenv_values
config = dotenv_values(".env.local")
IG_ACCESS_TOKEN = config['IG_ACCESS_TOKEN']
IG_USER_ID = config['IG_USER_ID']
CLOUDINARY_CLOUD_NAME = config['CLOUDINARY_CLOUD_NAME']
CLOUDINARY_API_KEY = config['CLOUDINARY_API_KEY']
CLOUDINARY_API_SECRET = config['CLOUDINARY_API_SECRET']
try:
cloudinary.config(
cloud_name=CLOUDINARY_CLOUD_NAME,
api_key=CLOUDINARY_API_KEY,
api_secret=CLOUDINARY_API_SECRET
)
print('cloudinary configured..')
result = cloudinary.Search()\
.expression('folder:instagram/*')\
.with_field('context')\
.execute()
from dotenv import load_dotenv, dotenv_values
import jesse.helpers as jh
import os
import sys
# fix directory issue
sys.path.insert(0, os.getcwd())
ENV_VALUES = {}
if jh.is_jesse_project():
# load env
load_dotenv()
# create and expose ENV_VALUES
ENV_VALUES = dotenv_values('.env')
if jh.is_unit_testing():
ENV_VALUES['POSTGRES_HOST'] = '127.0.0.1'
ENV_VALUES['POSTGRES_NAME'] = 'jesse_db'
ENV_VALUES['POSTGRES_PORT'] = '5432'
ENV_VALUES['POSTGRES_USERNAME'] = '******'
ENV_VALUES['POSTGRES_PASSWORD'] = '******'
ENV_VALUES['REDIS_HOST'] = 'localhost'
ENV_VALUES['REDIS_PORT'] = '6379'
ENV_VALUES['REDIS_DB'] = 0
ENV_VALUES['REDIS_PASSWORD'] = ''
# validation for existence of .env file
if len(list(ENV_VALUES.keys())) == 0:
jh.error(
'-o',
'--override',
help=
'Pin files from scratch, do not ignore files that have already been pinned',
default=False,
required=False,
action='store_true')
parser.add_argument('-r',
'--reverse',
help='Pin files in verse',
default=False,
required=False,
action='store_true')
args = vars(parser.parse_args())
credentials = dotenv_values(args['env'])
logger.info(f'Loading .env file from {args["env"]}')
results_fp = f'{args["input"]}/results.json'
files_to_upload = sorted(get_files(args['input']), reverse=args['reverse'])
if os.path.exists(results_fp) and not args['override']:
with open(results_fp, 'r') as f:
info = json.load(f)
f.close()
else:
info = {}
for idx, fp in enumerate(files_to_upload):
from collections import defaultdict
import numpy as np
from datetime import datetime
import SteamMarket
from time import sleep
from dotenv import dotenv_values
# COOKIE = {"steamLoginSecure": environ["STEAM_LOGIN_SECURE"]}
GAME_ID_1 = dotenv_values('.env')['GAME_ID_1']
SteamMarket.set_cookies(dotenv_values('.env')["STEAM_LOGIN_SECURE"])
SteamMarket.iniate_cookies()
all_items_names = [
"Sticker | FaZe Clan | Berlin 2019",
"Sticker | CR4ZY | Berlin 2019",
"Sticker | mousesports (Holo) | Berlin 2019",
"Sticker | FaZe Clan (Holo) | Berlin 2019",
"Sticker | Natus Vincere (Holo) | Berlin 2019",
"Sticker | compLexity Gaming | Berlin 2019",
"Sticker | mousesports (Foil) | Berlin 2019",
"Sticker | Team Liquid (Holo) | Berlin 2019",
"Sticker | Natus Vincere | Berlin 2019",
"Sticker | Team Liquid | Berlin 2019",
"Sticker | FaZe Clan (Foil) | Berlin 2019",
"Lt. Commander Ricksaw | NSWC SEAL",
"Sticker | ropz (Foil) | London 2018",
"Operation Phoenix Weapon Case",
"Shattered Web Case",
"Galil AR | Akoben (Field-Tested)",
"SSG 08 | Bloodshot (Field-Tested)",
"SG 553 | Colony IV (Field-Tested)",
import os
import sys
from pathlib import Path
from dotenv import dotenv_values
from client_config import get_client
# Load environment variables from .env file
env_path = Path(os.path.dirname(__file__)).absolute() / '.env'
if not env_path.exists():
print("Could not find '.env' file. Verify if you have in your directory.")
exit()
# Constants
ENV = dotenv_values(dotenv_path=env_path)
PWD = Path(os.path.dirname(__file__))
# --------Configuration--------
config = {
"cogs_path": PWD.joinpath('packages', 'cogs'),
"cogs_module_name": 'packages.cogs'
}
client = get_client(config)
# The token is necessary to connect the client with the API
# on discord and use the bot.
client.run(ENV['BOT_TOKEN'])
import mysql.connector
from dotenv import dotenv_values, find_dotenv
env_values = dotenv_values(find_dotenv())
mydb = mysql.connector.connect(host=env_values.get('SQL_HOST'),
user=env_values.get('SQL_USER'),
password=env_values.get('SQL_PASSWORD'),
database=env_values.get('SQL_DB'))
def findMovieFile(id):
mycursor = mydb.cursor()
mycursor.execute(f"SELECT file_path FROM Movies where movie_id={id}")
movies = mycursor.fetchall()
if (len(movies) == 0):
raise Exception('Invalid id provided')
else:
return movies[0]
from biosimulators_utils.sedml.data_model import Report, Plot2D, Plot3D
from biosimulators_utils.sedml.exec import get_report_for_plot2d, get_report_for_plot3d
from biosimulators_utils.sedml.io import SedmlSimulationReader
from biosimulators_utils.viz.data_model import VizFormat
from dotenv import dotenv_values
from unittest import mock
import connexion
import flask
import os.path
import requests
import requests.exceptions
import werkzeug.wrappers.response # noqa: F401
import zipfile
config = {
**dotenv_values("secret/secret.env"),
**dotenv_values("config/config.env"),
**dotenv_values("shared/shared.env"),
}
TIMEOUT = float(config.get('RUN_COMBINE_ARCHIVE_TIMEOUT', 30.))
IGNORED_ENV_VARS = [
'H5_REPORTS_PATH',
'REPORTS_PATH',
'PLOTS_PATH',
'BUNDLE_OUTPUTS',
'KEEP_INDIVIDUAL_OUTPUTS',
'LOG_PATH',
]
from faunadb import query as q
from faunadb.objects import Ref
from faunadb.client import FaunaClient
from dotenv import dotenv_values
from munch import AutoMunch
from pprint import pprint
cfg = AutoMunch(dotenv_values())
# pprint(cfg)
# exit()
fdb = FaunaClient(secret=cfg.FAUNASECRET)
if __name__ == "__main__":
indexes = fdb.query(q.paginate(q.collections()))
pprint(indexes)
"tests/test-files/decoded_test_b.PNG"),
],
)
def test_base64_to_file(base64_path, save_path):
assert (base64_to_content(
base64_path, is_path=True,
save_path=save_path) == "Successfully saved to `%s`" % save_path)
"""
UTILS TESTS
"""
from misty2py.utils.utils import *
from dotenv import dotenv_values
values = dotenv_values(".env")
@pytest.mark.parametrize(
"in_val, query_str, fallback, query_type, out_val",
[
({
"test": "testing"
}, "test", 0, str, "testing"),
({
"test": "testing"
}, "test", 0, int, 0),
({
"tost": "testing"
}, "test", 0, int, 0),
],
import numpy as np
import matplotlib.pyplot as plt
import sys
import jsonpickle.ext.numpy as jsonpickle_numpy
jsonpickle_numpy.register_handlers()
import jsonpickle
from qctrlvisualizer import get_qctrl_style, plot_controls
from qctrl import Qctrl
#configure environment
from dotenv import dotenv_values
config = dotenv_values(".env")
import real_q
#open file and decode it
if (len(sys.argv) < 2):
print("Enter a json pickle path as first arg!")
exit(0)
path = sys.argv[1]
print(path)
circuit = "H"
if ("not" in path):
circuit = "NOT"
json_encode = None
with open(path, 'r') as file:
json_encode = file.read()
def load_env_files() -> Generator[Dict[str, str], None, None]:
for env_file in env_files():
d = dotenv_values(env_file, interpolate=False)
yield {k: v for k, v in d.items() if v is not None}
Import("env")
import sys
env.Execute("$PYTHONEXE -m pip install python-dotenv")
from dotenv import dotenv_values
config = {
**dotenv_values(".env"),
**dotenv_values(".env." + env["PIOENV"]),
}
env.Append(CPPDEFINES=config.items())
env.Append(OTA_PASSWORD=config["DEVICE_SECRET"])
For more information on this file, see
https://docs.djangoproject.com/en/3.1/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.1/ref/settings/
"""
from pathlib import Path
from dotenv import dotenv_values
from os import path as os_path
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
dot_env_variables = dotenv_values()
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = dot_env_variables['DJANGO_SECRET_KEY']
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True if dot_env_variables['APP_ENV'] == 'development' else False
ALLOWED_HOSTS = dot_env_variables['ALLOWED_HOSTS'].split(
',') if 'ALLOWED_HOSTS' in dot_env_variables else ['*']
# Application definition
'debug', 'trace'
],
default='info')
args = parser.parse_args()
BASE_PATH = args.kvm_path
logger.remove()
logger.add(sys.stdout, level=args.log_level.upper())
def get_path(file_path: str) -> PurePath:
return PurePath(BASE_PATH).joinpath(file_path)
default_config = dotenv_values(str(get_path('.env')))
customized_config = {'DB_NAME': 'kartevonmorgen.sqlite'}
if Path(get_path('.env.production')).exists():
customized_config = dotenv_values(str(get_path('.env.production')))
if args.dev:
customized_config = dotenv_values(str(get_path('.env.development')))
config = {**default_config, **customized_config, **os.environ}
# log configurations
logger.debug(f'base path: {BASE_PATH}')
logger.debug(f'default config: {default_config}')
logger.debug(f'customized config: {customized_config}')
DB_PATH = get_path(str(PurePath('db').joinpath(config['DB_NAME'])))
def test_dotenv_values_stream():
stream = StringIO(u'hello="it works!😃"\nDOTENV=${hello}\n')
stream.seek(0)
parsed_dict = dotenv_values(stream=stream)
assert 'DOTENV' in parsed_dict
assert parsed_dict['DOTENV'] == u'it works!😃'
