def sendmail(msgbody, subject=f"[{AppName}] Alert!", forced=False):
ini = Config.getboolean('notification', 'email', fallback=True)
if not forced and not ini:
return
smtp_server = "smtp.gmail.com"
port = 587 # For starttls
context = ssl.create_default_context()
password = Config['email']['password']
sender = Config['email']['sender']
tolist = Config['email']['to']
cclist = Config.get('email', 'cc', fallback="")
with smtplib.SMTP(smtp_server, port) as server:
server.ehlo() # Can be omitted
server.starttls(context=context)
server.ehlo() # Can be omitted
server.login(sender, password)
rcpt = cclist.split(",") + [tolist]
msg = MIMEMultipart('alternative')
msg['Subject'] = subject
msg['To'] = tolist
msg['Cc'] = cclist
msg.attach(MIMEText(msgbody))
server.sendmail(sender, rcpt, msg.as_string())
server.quit()
def bounce_ball(self, ball):
if self.collide_widget(ball):
#self.pong_sound.play()
randomness = random() * 0.4 + 0.8
speedup = Config.get('speedup') * randomness
offset = Config.get('offset') * \
Vector(0, ball.center_y-self.center_y)
ball.velocity = speedup * \
Vector(-ball.velocity_x, ball.velocity_y) + offset
def __init__(self, bot):
self.bot = bot
self.session = {}
conf = Config("config.ini")
trans_conf = conf.get("Translation")
i18n.set("locale", trans_conf['default_locale'])
i18n.set("file_type", "json")
i18n.load_path.append(trans_conf['path'])
async def data_handler(request):
# get data from request
data = request.json
if data is None:
return json({"status": 403, "message": "expected json"})
token = tokens.get(data.get('via_instance'), '')
# the session might be saved in the database
if not token:
potential_session = await database.get_session(data.get('via_instance'))
if potential_session:
# it is, we save it in the cache and set the token to the retrieved values
tokens[potential_session["name"]] = Config(potential_session["token"], potential_session["url"])
token = tokens.get(data.get('via_instance'))
# `not token` to avoid `'' == ''`
if not token or not (data.get("security_token", '') == token.token):
# add custom 403 error code
return json({"status": 403, "message": "token unauthorized"})
# build into context
result = Context.from_json(data)
# verify context `required` attributes
if not result.validated:
# add custom 403 error code
return json({"status": 403, "message": result.error})
# Validated object
ctx = result.object
# Replace security token to the server's after validation
ctx.replace_security_token()
# process message
handler.process(ctx)
# return context
return json(ctx.ok)
def set_time_interval(from_day: float, to_day: float):
"""
Sets start time and stop time to param.in file.
:param from_day:
:param to_day:
:return:
"""
def _edit_file(filepath: str, callback: Callable[[Iterable[str], TextIO], None]):
with open(filepath) as f:
out_fname = filepath + ".tmp"
out = open(out_fname, "w")
callback(f, out)
out.close()
os.rename(out_fname, filepath)
def _update_params(infile: Iterable[str], outfile: TextIO):
startday_pattern = ' start time (days)= '
stopday_pattern = ' stop time (days) = '
for line in infile:
if line.startswith(startday_pattern):
line = '%s%f\n' % (startday_pattern, from_day)
if line.startswith(stopday_pattern):
line = '%s%f\n' % (stopday_pattern, to_day)
outfile.write(line)
integrator_path = opjoin(Config.get_project_dir(), CONFIG['integrator']['dir'])
param_in_filepath = opjoin(integrator_path, CONFIG.INTEGRATOR_PARAM_FILENAME)
_edit_file(param_in_filepath, _update_params)
def twitch(*args, **kwargs):
token = request.args.get("access_token")
if token:
resp = get("https://api.twitch.tv/kraken/user",
headers={
"Accept":
"application/vnd.twitchtv.v5+json",
"Client-ID":
Config().get("Cresentials")['twitch-cid'],
"Authorization":
f"OAuth {token}"
}).json()
_name = resp['display_name']
_uid = resp['name']
_tid = resp['_id']
_email = resp.get('email')
_first_join, _uuid = self.db.add_user("twitch",
email=_email,
name=_name,
uid=_uid,
tid=_tid,
now=session.get("uuid"))
session['uuid'] = _uuid
if not isinstance(session.get('li_platform'), dict):
session['li_platform'] = {}
session['li_platform']['twitch'] = {"name": _name}
return render_template("ok.html")
else:
return render_template("index.html")
def refresh():
lpath = Config.value(Config.LIBRARY) # book location
MODEL.clear()
MODEL.setHorizontalHeaderLabels(['Book/Language/Chapter', ''])
bookfiles = glob.glob(lpath+"/*.json")
for bookf in bookfiles:
bi = model.BookInfo.fromJsonFile(bookf)
book_node = QtGui.QStandardItem(res.book_icon, bi.bookid)
book_node.setData(bi)
MODEL.appendRow(book_node)
for tr in bi.translations:
# Create Language Node
lang_node = QtGui.QStandardItem(res.lang_icon, tr.language)
lang_node.setData(tr)
book_node.appendRow(lang_node)
for chapter in tr.chapters:
# Create Chapter Node
chnum = chapter.idx
chapter_title = model.CHAPTER_CAPTION[tr.language] + ' %04d' % chnum
ch_icon = res.play_icon if chapter.downloaded else res.dl_icon
chapter_node = QtGui.QStandardItem(ch_icon, chapter_title)
chapter.treeNode = chapter_node
chapter_node.setData(chapter)
lang_node.appendRow(chapter_node)
# adjust column sizes on the tree view
TREE_VIEW.resizeColumnToContents(0)
TREE_VIEW.resizeColumnToContents(1)
def __init__(self, root):
self.config = Config("tkc.ini")
root.title("Tkinter Commander")
root.protocol("WM_DELETE_WINDOW", self.on_delete)
self.root = root
root.geometry(self.config.get("fm_geometry"))
root.grid_columnconfigure(0, weight=1)
root.grid_rowconfigure(1, weight=1)
pw = Panedwindow(root, orient="horizontal", takefocus=False)
frame = Frame(pw)
self.left = Panel(frame, Local_fs(), self.config)
pw.add(frame)
pw.pane(frame, weight=1)
frame = Frame(pw)
self.right = Panel(frame, Local_fs(), self.config)
self.right.oposite = ref(self.left)
self.left.oposite = ref(self.right)
self.left.activate()
pw.add(frame)
pw.pane(frame, weight=1)
pw.grid(column=0, row=1, columnspan=2, sticky="senw")
self.add_menu()
self.add_btns()
root.tk.call(
"wm", "iconphoto", root._w,
PhotoImage(file=join(dirname(__file__), "data", "favicon.gif")))
def play_sound(times=1, forced=False):
ini = Config.getboolean('notification', 'playsound', fallback=True)
if not forced and not ini:
return
mp3_file = Config['media']['soundtrack']
for i in range(times):
playsound(mp3_file)
def push_bullet(message, title='Fishing', forced=False):
ini = Config.getboolean('notification', 'pushbullet', fallback=True)
if not forced and not ini:
return
api_key = Config['pushbullet']['key']
pb = Pushbullet(api_key)
pb.push_note(title, message)
def __init__(self):
#logging.basicConfig(filename='esmart3.log', level=logging.INFO)
#self.logger = logging.getLogger('esmart3')
#self.logger.setLevel(logging.DEBUG)
#self.logger.info('Started')
self.config = Config()
self.ser = serial.Serial(self.config.dev, 9600, timeout=0.1)
self.ser.port = self.config.dev
self.varBatCap = 0
def __init__(self, parent=None):
super(ReaderWidget, self).__init__(parent)
self._autoScroll = Config.value(Config.AUTO_SCROLL)
self.readerPane = ReaderPane(parent=parent,
autoScroll=self._autoScroll)
self.readerPane.setReadOnly(True)
readerPaneLayout = QtWidgets.QVBoxLayout()
readerPaneLayout.addWidget(self.readerPane)
self.setLayout(readerPaneLayout)
def create_app():
app = Flask(__name__)
environment_config = Config.for_actual_environment()
app.config.from_object(environment_config)
mongo.init_app(app)
set_up_sentry(environment_config)
register_endpoints(app)
return app
async def main():
conf = Config()
logging.basicConfig(level=logging.DEBUG)
logging.config.dictConfig(conf.DEFAULT_LOGGING)
logger = logging.getLogger(__name__)
db = ExtendedDBManager(init_db(conf))
db.database.create_tables([Article], safe=True)
executor = ThreadPoolExecutor(max_workers=10)
loop.set_default_executor(executor)
DATA_FOR_MATPLOTLIB = {}
await truncate(db=db)
await vacuum(db=db)
await drop_index(db=db)
for mode in ["noindex", 'index']:
await truncate(db=db)
await vacuum(db=db)
if mode == 'index':
await create_index(db=db)
else:
await drop_index(db=db)
for i in range(1, 81):
await buck_create_new(db=db, epoch_count=i, count=10**6, mode=mode)
row1 = await db.get(Article.select().limit(1))
row2 = await db.get(Article.select().order_by(
Article.created_date.desc()).limit(1))
if mode == 'noindex':
arv_time__noindex1 = await call_avr_time(db=db, text=row1.name)
arv_time__noindex2 = await call_avr_time(db=db, text=row2.name)
arv_time__noindex = max(arv_time__noindex1, arv_time__noindex2)
logger.info(f"Time NoIndex={arv_time__noindex}")
DATA_FOR_MATPLOTLIB[str(i)] = {"noindex": arv_time__noindex}
else:
arv_time__index1 = await call_avr_time(db=db, text=row1.name)
arv_time__index2 = await call_avr_time(db=db, text=row2.name)
arv_time__index = max(arv_time__index1, arv_time__index2)
logger.info(f"Time Index={arv_time__index}")
DATA_FOR_MATPLOTLIB[str(i)].update({"index": arv_time__index})
logger.info(f"")
now_count = await db.count(Article.select())
logger.info(f"Row in db count = {now_count}")
logger.info(f"== == " * 15)
logger.info(f"== == " * 15)
FileReader.write_data(DATA_FOR_MATPLOTLIB)
logger.info(f"Exit")
def root(*_, **__):
if not session.get("credentials") or not session.get(
"credentials")['logged_in']:
return sender.render_template(self,
"index.html",
navbar_active="login",
oauth=Config().get("OAuth"),
redirect_uri=request.args.get(
"redirect_uri", "/"))
return redirect(request.args.get("redirect_uri", "/"), 302)
def __init__(self, name, *args, **kwargs):
super().__init__("Discord")
self.__name__ = name
self.client = Client()
self.token = kwargs.get("token", None)
self._config = Config()
self.groups = {}
self.cases = {}
self._run = self.run
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
player = Config.get('players')
self.player_list = [None] * 2
self.player1widget = self.ids.player_1
self.player2widget = self.ids.player_2
for i in range(2):
widget = self.player1widget if i == 0 else self.player2widget
if player[i] == "Human":
self.player_list[i] = Human(widget)
elif isinstance(player[i], list):
if player[i][0] == "Heuristic":
self.player_list[i] = Heuristic(player[i][1], widget, self)
Clock.schedule_interval(self.player_list[i].play, \
1.0/float(Config.get('frame_limit')))
else:
raise Exception("Config Error: Malformatted AI entry!")
exit(1)
else:
raise Exception("Config Error: AI Type not understood!")
exit(1)
class Attendance:
def __init__(self, bot):
self.bot = bot
self.session = {}
conf = Config("config.ini")
trans_conf = conf.get("Translation")
i18n.set("locale", trans_conf['default_locale'])
i18n.set("file_type", "json")
i18n.load_path.append(trans_conf['path'])
DB = PostgreSQL(**Config("config.ini").get("Database"))
def __unload(self):
self.DB.close()
async def on_ready(self):
print(" [ATd] Successfully loaded.")
@checks.is_user(DB)
@command("출석", pass_context=True)
async def add_attendance(self, ctx):
_, uuid = users.get_uuid(self.DB, ctx.message.author.id)
if uuid is None:
await ctx.bot.reply(t("messages.register_request"))
return
_, data = self.DB.rnf(
f"SELECT date FROM attendance WHERE uuid='{uuid}' and date >= current_date;"
)
if data:
await ctx.bot.reply(t("messages.attendance_already"))
return
_, data = self.DB.rnf(
f"INSERT INTO attendance (uuid) VALUES ('{uuid}') RETURNING date;")
if data:
await ctx.bot.reply(
t("messages.attendance_success").format(time=data[0][0]))
return
await ctx.bot.reply(t("messages.error_call_admin"))
@add_attendance.error
async def error_add_attendance(self, error, ctx):
if isinstance(error, CheckFailure):
await ctx.bot.reply(t("messages.register_request"))
print(error)
def generate_data(settings, interval, full_reset):
st.sidebar.markdown('### Generating Data')
del os.environ['TZ']
# os.environ['TZ'] = ORIGINAL_TIMEZONE
GitHistoryConverter(
settings,
Config(interval, full_reset),
update_progress=update_progress_bar,
setup_progress=setup_progress_bar
).convert()
os.environ['TZ'] = 'UTC'
st.caching.clear_cache()
st.balloons()
def configure_server(config: Optional[Config] = None) -> web.Application:
if not config:
config = Config() # use default values
app = web.Application()
app['config'] = config
app.on_startup.append(create_morpher)
app.on_startup.append(load_charged_words)
app.on_startup.append(init_cache)
app.cleanup_ctx.append(create_aiohttp_session)
app.add_routes([
web.get('/', index, name='index'),
web.get('/health', health, name='health'),
])
return app
def notifyrun(msg, forced=False):
ini = Config.getboolean('notification', 'notifyrun', fallback=True)
if not forced and not ini:
return
# put the sending work in thread in case there's delay in
# accessing notifyrun's server
channel = Config['notifyrun']['channel']
def send():
notify = Notify(endpoint=f"https://notify.run/{channel}")
notify.send(msg)
threading.Thread(target=send, args=()).start()
def __init__(self, book_info, lang, title, content_url):
"""Initialize information on a book"""
cpath = Config.value(Config.CONTENT) # book contents
self.book = book_info # identifier of the book
self.book_path = os.path.join(cpath, book_info.bookid,
lang) # root path of the book
self.book_file = os.path.join(self.book_path,
BOOK_FILE) # path to the local file
self.language = lang # Language
self.title = title # Title
self.content_url = content_url # URL of the content
self.chapters = [] # List of chapters
self.book.addTranslation(self)
self.updateStatus() # update download status
def showSearch(parent):
dialog = SearchDialog(parent)
result = dialog.exec_()
if result == QtWidgets.QDialog.Accepted:
for i in range(dialog.model.rowCount()):
itm = dialog.model.item(i)
if itm.checkState() == Qt.Checked:
book_id = itm.text() # selected book identifier
book_def = book_manager.getNetBook(book_id) # get the book configuration
lpath = Config.value(Config.LIBRARY) # save location
os.makedirs(lpath, exist_ok=True)
fname = os.path.join(lpath, book_id + ".json")
with open(fname, 'w') as f:
f.write(book_def)
parent.updateLibrary()
def decorated_view(*args, **kwargs):
if request.method in EXEMPT_METHODS:
return func(*args, **kwargs)
environment_config = Config.for_actual_environment()
if not environment_config.need_authorization():
return func(*args, **kwargs)
token = request.headers.get('Authorization')
if token != environment_config.token():
return json.dumps({
"object": {},
"errors": ["Ingreso no permitido"]
}), 403
return func(*args, **kwargs)
def __init__(self):
logging.basicConfig(filename='esmart3.log', level=logging.INFO)
self.logger = logging.getLogger('esmart3')
#self.logger.setLevel(logging.DEBUG)
self.logger.info('Started')
self.chgMode = ["IDLE", "CC", "CV", "FLOAT", "STARTING"]
self.batType = ["User-defined", "Flooded", "Sealed", "Gel"]
self.fault = [
"Battery voltage over", "PV voltage over", "Charge current over",
"Dis-charge over", "Battery temperature alarm",
"Internal temperature alarm", "PV voltage low",
"Battery voltage low", "Trip zero protection trigger",
"In the control of manual switchgear"
]
self.config = Config()
self.ser = serial.Serial(self.config.dev, 9600, timeout=0.1)
self.ser.port = self.config.dev
# encoding=utf8
import subprocess
from settings import Config
MEDIA_REMOTE_URL = Config.get_config()['media_remote_url']
APP_SOURCE_REMOTE_URL = Config.get_config()['app_source_remote_url']
MEDIA_DIR = Config.get_config()['media_dir']
APP_SOURCE_DIR = Config.get_config()['app_source_dir']
C_APP = 'APP'
C_MEDIA = 'MEDIA'
def git(repo_dir, *args):
ret = subprocess.check_output(['git'] + list(args), cwd=repo_dir)
print('git ' + str(list(args)))
return ret
def pip(*args):
ret = subprocess.check_output(['pip'] + list(args))
return ret
def isUpToDate(repo_dir):
# git fetch origin
# "--git-dir=" + repo_dir + "/.git"
git(repo_dir, "fetch", 'origin', 'master')
sha1_rev_local = ''
sha1_rev_remote = ''
# local VS remote
# git rev-parse @ VS git rev-parse @{u}
from math import radians
import pytest
from datamining import OrbitalElementSet
from datamining import OrbitalElementSetCollection
from datamining.orbitalelements.collection import AEIValueError
from os.path import join as opjoin
from settings import Config
PROJECT_DIR = Config.get_project_dir()
PARAMS = Config.get_params()
A1_AEI_FILE_LEN = 46
def test_orbital_elements():
filepath = opjoin(PROJECT_DIR, PARAMS['integrator']['dir'], 'A1.aei')
collection = OrbitalElementSetCollection(filepath)
assert len(collection.orbital_elements) == A1_AEI_FILE_LEN
assert len(collection) == A1_AEI_FILE_LEN
orbitalelements = collection.orbital_elements[0]
assert orbitalelements == collection[0]
assert orbitalelements.time == 0.0000000
assert orbitalelements.p_longitude == radians(1.541309E+02)
assert orbitalelements.mean_anomaly == radians(3.172742E+02)
assert orbitalelements.semi_axis == 2.76503
assert orbitalelements.eccentricity == 0.077237
assert orbitalelements.inclination == radians(int(10.6047))
assert orbitalelements.node == radians(int(80.4757))
import redis
from sqlalchemy import create_engine, Integer, Column
from sqlalchemy.ext.declarative import as_declarative
from sqlalchemy.orm import Session
from sqlalchemy.orm import sessionmaker
from sqlalchemy.sql import ClauseElement
from alembic.config import Config as AlembicConfig
import os
from settings import Config
from sqlalchemy import event
from sqlalchemy.engine import Engine
import time
import logging
CONFIG = Config.get_params()
_HOST = CONFIG['postgres']['host']
_USER = CONFIG['postgres']['user']
_PASSWORD = CONFIG['postgres']['password']
_DB = CONFIG['postgres']['db']
if CONFIG['debug']:
logging.basicConfig()
logger = logging.getLogger("myapp.sqltime")
logger.setLevel(logging.DEBUG)
@event.listens_for(Engine, "before_cursor_execute")
def before_cursor_execute(conn, cursor, statement, parameters, context, executemany):
conn.info.setdefault('query_start_time', []).append(time.time())
logger.debug("Start Query: %s", statement % parameters)
"[%(levelname)-8s] %(filename)s => %(asctime)s | %(message)s")
if not "logs" in os.listdir():
os.mkdir("logs")
FileLogger = logging.FileHandler("./logs/lastest.log")
FileLogger.setFormatter(formatter)
FileLogger.setLevel(logging.DEBUG)
logger.addHandler(FileLogger)
StreamLogger = logging.StreamHandler()
StreamLogger.setFormatter(formatter)
StreamLogger.setLevel(logging.DEBUG)
logger.addHandler(StreamLogger)
HookConfig = Config().get("Hook")
DiscordLogger = DLogger(HookConfig)
DiscordLogger.setFormatter(formatter)
DiscordLogger.setLevel(logging.WARNING)
logger.addHandler(DiscordLogger)
class CrawlBot:
def __init__(self):
self.is_alive = True
self.loop = asyncio.get_event_loop()
async def teardown(self):
logger.warn(" ! TEARDOWN ! Event loop was died")
def run(self):
from os.path import join as opjoin
from shutil import copyfile
import os
from settings import Config
PROJECT_DIR = Config.get_project_dir()
INTEGRATOR_PATH = opjoin(PROJECT_DIR, Config.get_params()['integrator']['dir'])
PARAMS = Config.get_params()
def test_set_time_interval():
from integrator import set_time_interval
def _copyfile(name: str):
path = opjoin(INTEGRATOR_PATH, name)
target = opjoin(INTEGRATOR_PATH, name + '.backup')
copyfile(path, target)
return path
param_in_filepath = _copyfile(PARAMS.INTEGRATOR_PARAM_FILENAME)
set_time_interval(1, 2)
startday_assert_flag = False
stopday_assert_flag = False
with open(param_in_filepath) as f:
for line in f:
startday_assert_flag = startday_assert_flag or (' start time (days)= 1' in line)
stopday_assert_flag = stopday_assert_flag or (' stop time (days) = 2' in line)
assert startday_assert_flag
from .facades import PhaseCountException
from .collection import OrbitalElementSet
from os.path import exists as opexists
from os.path import join as opjoin
from os.path import isabs
from os import makedirs
import glob
from tarfile import is_tarfile
from tarfile import open as taropen
import os
from settings import Config
import shutil
from os.path import basename
PROJECT_DIR = Config.get_project_dir()
CONFIG = Config.get_params()
_ex_folder = CONFIG['extract_dir']
EXTRACT_PATH = _ex_folder if isabs(_ex_folder) else opjoin(PROJECT_DIR, _ex_folder)
BUCKET = CONFIG['s3']['bucket']
_s3_folder = CONFIG['s3files_dir']
S3_FILES_DIR = _s3_folder if isabs(_s3_folder) else opjoin(PROJECT_DIR, _s3_folder)
class FilepathException(Exception):
pass
class FilepathInvalidException(Exception):
pass
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
except:
from email.MIMEMultipart import MIMEMultipart
from email.MIMEText import MIMEText
from datetime import datetime,date,timedelta,time
from pytz import timezone,utc
from threading import Timer
import codecs
from models import Reservation, Flight, FlightLeg, FlightLegLocation
# Load settings
from settings import Config
config = Config()
from db import Database
from tasks import *
# ========================================================================
base_url = 'http://www.southwest.com'
checkin_url = urlparse.urljoin(base_url, '/flight/retrieveCheckinDoc.html')
retrieve_url = urlparse.urljoin(base_url, '/flight/lookup-air-reservation.html')
# Common US time zones
tz_alaska = timezone('US/Alaska')
tz_aleutian = timezone('US/Aleutian')
tz_arizona = timezone('US/Arizona')
tz_central = timezone('US/Central')
from settings import Config
from engine import FlaskEngine
config = Config()
engine = FlaskEngine(
config.get("Web"),
webpages=[
"pages.root",
"pages.login",
"pages.sso",
"pages.service",
"pages.profile",
"pages.rank"
]
)
engine.run()
def __init__(self) -> None:
self._config = Config()
self._engine = None
from os import urandom
from flask import Flask, session
from pages import blueprints as bps
from settings import Config
conf = Config()
app_config = conf.get("Web")
_temp = app_config.get("secret_key")
if _temp:
_secret_key = app_config.get("secret_key")
del app_config["secret_key"]
else:
_secret_key = urandom(32)
app = Flask(__name__)
app.secret_key = _secret_key
@app.before_request
def make_empty_session(*_, **__):
if not session.get("credentials"):
session['credentials'] = {
"logged_in": False,
"display_name": "placeholder"
}
for module in bps:
if not hasattr(module, "setup"):
raise Exception("An improper blueprint module was passed")
from celery import Celery
from celery.task import task, periodic_task
from settings import Config
def make_celery(app):
celery = Celery(app.import_name, broker=Config.BROKER_URL)
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
from app import create_app
app = create_app(Config())
celery = make_celery(app)
@task
def test():
print session
class Face:
def __init__(self, root):
self.config = Config("tkc.ini")
root.title("Tkinter Commander")
root.protocol("WM_DELETE_WINDOW", self.on_delete)
self.root = root
root.geometry(self.config.get("fm_geometry"))
root.grid_columnconfigure(0, weight=1)
root.grid_rowconfigure(1, weight=1)
pw = Panedwindow(root, orient="horizontal", takefocus=False)
frame = Frame(pw)
self.left = Panel(frame, Local_fs(), self.config)
pw.add(frame)
pw.pane(frame, weight=1)
frame = Frame(pw)
self.right = Panel(frame, Local_fs(), self.config)
self.right.oposite = ref(self.left)
self.left.oposite = ref(self.right)
self.left.activate()
pw.add(frame)
pw.pane(frame, weight=1)
pw.grid(column=0, row=1, columnspan=2, sticky="senw")
self.add_menu()
self.add_btns()
root.tk.call(
"wm", "iconphoto", root._w,
PhotoImage(file=join(dirname(__file__), "data", "favicon.gif")))
def add_menu(self):
top = self.root
top["menu"] = menubar = Menu(top)
menu_file = Menu(menubar)
menu_settings = Menu(menubar)
menu_help = Menu(menubar)
menubar.add_cascade(menu=menu_file, label=_("File"))
menubar.add_cascade(menu=menu_settings, label=_("Settings"))
menubar.add_cascade(menu=menu_help, label=_("Help"))
menu_settings.add_command(label=_("Pannel Settings"),
command=self.dlg_panset)
def add_btns(self):
root = self.root
frame = Frame(root)
for key, text, command in (
(3, _("F3 View"), self.on_F3),
(4, _("F4 Edit"), self.on_F4), (5, _("F5 Copy"), self.on_F5),
(6, _("F6 Move"), self.on_F6),
(7, _("F7 Make Directory"), self.on_F7),
(8, _("F8 Remove"), self.on_F8),
(10, _("F10 Exit"), self.on_F10)):
btn = Button(frame, text=text, command=command, takefocus=False)
btn.pack(side="left", fill="x", expand=True)
root.bind_all("<F%d>" % key, func=command)
sz = Sizegrip(frame)
sz.pack(side="right", anchor="se")
frame.grid(column=0, row=2, columnspan=2, sticky="we")
def get_panels(self):
"returns (active, passive) panels"
if self.left.is_active:
return self.left, self.right
return self.right, self.left
def on_delete(self):
self.config["fm_geometry"] = self.root.geometry()
self.config.save()
self.root.destroy()
def on_F3(self, evt=None):
print("F3")
def on_F4(self, evt=None):
print("F4")
def on_F5(self, evt=None):
buttons.copy_button(self)
def on_F6(self, evt=None):
print("F6")
def on_F7(self, evt=None):
print("F7")
def on_F8(self, evt=None):
print("F8")
def on_F10(self, evt=None):
self.on_delete()
def dlg_panset(self):
from dialogs import Dlg_panset
Dlg_panset(self.root, self.config)
from override import CrescBot
from settings import Config
cogs = [
"cogs.test", "cogs.vip", "cogs.members", "cogs.attendance", "cogs.admin"
]
_conf = Config("config.ini")
_token = _conf.get("Credential.token")
bot = CrescBot(command_prefix="크센아 ")
for cog in cogs:
bot.load_extension(cog)
bot.run(_token)
from math import radians
from math import sqrt
from typing import List, Tuple
from settings import Config
SMALL_BODY = 'small_body'
CONFIG = Config.get_params()
OUTPUT_ANGLE = CONFIG['output']['angle']
BODIES_COUNTER = CONFIG['integrator']['number_of_bodies']
SMALL_BODIES_FILENAME = CONFIG['integrator']['files']['small_bodies']
HEADER_LINE_COUNT = 4
class AEIValueError(ValueError):
pass
class OrbitalElementSet:
_TIME = 0
_PERIHELLION_LONGITUDE = 1
_MEAN_ANOMALY = 2
_SEMIMAJOR_AXIS = 3
_ECCENTRICITY = 4
_INCLINATION = 5
_NODE = 7
def __init__(self, data_string: str):
"""Data string must be formated as data in aei file, that generates by element6.
:param data_string:
:except ValueError: if data from data_string has incorrect values.
