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.sessions = {}
conf = Config("config.ini")
self.DB = PostgreSQL(**conf.get("Database"))
trans_conf = conf.get("Translation")
i18n.set("locale", trans_conf['default_locale'])
i18n.set("file_type", "json")
i18n.load_path.append(trans_conf['path'])
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)
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()
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 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")
class TheMoviedbCrawler(Crawler):
API_KEY = Config.get('themoviedb', 'token')
REQUEST_DELAY = 0.5
SERVICE = 'themoviedb'
LETTERS = ' 0123456789' + string.ascii_lowercase
@classmethod
def api_url(cls, uid, subpoint=''):
return 'http://api.themoviedb.org/3/{category}/{uid}{subpoint}?api_key={key}'\
.format(category=cls.CATEGORY, uid=uid, subpoint=subpoint, key=cls.API_KEY)
@classmethod
def pretty_url(cls, uid):
return 'http://themoviedb.org/{category}/{uid}'.format(category=cls.CATEGORY, uid=uid)
@classmethod
def get_from_api(cls, uid):
response = cls.REQUESTER.get(cls.api_url(uid))
if response.status_code == 200:
return json.loads(response.content)
else:
return {}
@classmethod
def get_uid(cls, url):
return os.path.basename(url)
@classmethod
def search_url(cls, year, query, page=None):
return 'http://api.themoviedb.org/3/search/{category}?api_key={api_key}&query={query}&{year_filter}={year}&page={page}'\
.format(category=cls.CATEGORY,
year_filter=cls.YEAR_FILTER,
api_key=cls.API_KEY,
year=year,
query=query,
page=page or '1')
@classmethod
def urls(cls, year):
for letter in cls.LETTERS:
cls.page_count = 0 # will be set upon first transform
yield cls.search_url(year, query=letter)
for page in xrange(2, cls.page_count + 1):
yield cls.search_url(year, query=letter, page=page)
@classmethod
def update(cls, content):
response = json.loads(content)
if cls.page_count == 0:
cls.page_count = response['total_pages']
@classmethod
def candidate_urls(cls, content):
response = json.loads(content)
results = response['results']
results = [result['id'] for result in results]
return map(cls.pretty_url, results)
@classmethod
def artists(cls, url):
response = cls.fetch_url(url)
if response.status_code == 200:
credits = json.loads(response.content)
return ([c['name'] for c in credits.get('crew', []) if c['department'] == 'Directing'][:1] or
[c['name'] for c in credits.get('crew', []) if c['department'] == 'Producer'][:1]) + \
[u'{}{}'.format(c['name'], u' ({})'.format(c['character']) if c.get('character') else '')
for c in credits.get('cast', [])[:5]]
else:
return []
@classmethod
def french_title(cls, url):
response = cls.fetch_url(url)
if response.status_code == 200:
try:
return filter(lambda entry: entry['iso_3166_1'] == 'FR',
json.loads(response.content))[0].get('title', '')
except:
return ''
else:
return ''
from os import urandom
from flask import Flask, session, request, redirect
from pages import blueprints as bps
from exceptions import InvalidModuleException
from settings import Config
from urllib.parse import urlparse, urlunparse
conf = Config()
app_config = conf.get("Web")
route_config = conf.get("URI")
DefaultHost = route_config.get("default_domain")
_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"
}
import os
import pandas as pd
from pandas import DataFrame
from database import links, tax
from file_op.json_op import load_json_from_file
from settings import Config
config = Config('FIELD')
FIELD_NUM = config.get('count')
FIELD_PRICE = config.get('price')
FIELD_UNIT = config.get('unit')
FIELD_COMMODITY = config.get('commodity')
FIELD_NUMBER = config.get('index')
FIELD_MONEY = config.get('money')
FIELD_LINK = config.get('link')
def get_df(file, fields):
df = pd.read_excel(file, header=None).dropna()
df.index = range(len(df))
df.columns = df.iloc[0]
df = df.drop(0)
for field in fields:
if field not in df.columns:
raise ValueError(f'字段{field}未发现')
return df
def summary(file_name):
import os
import asyncio
import logging
import aiohttp
import datetime as dtime
from core import CrawlBot
from logger import DBLogger
from settings import Config
# Retrieve Settings
_settings = Config()
_chain_settings = _settings.get("Chain")
_bot_settings = _settings.get("Bot")
_db_settings = _settings.get("Database")
# Setup Logger
logger = logging.getLogger("BloodCoinMainCore")
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter("[%(levelname)-8s] %(filename)s => %(asctime)s | %(message)s")
# Make Bot Client
client = CrawlBot()
async def timer():
CheckInterval = _bot_settings.get("check_interval")
logger.info(" * Checking web every " + str(CheckInterval) + " Seconds")
from discord.ext.commands.bot import _get_variable, Bot
from settings import Config
from i18n import t
import i18n
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'])
class CrescBot(Bot):
def __init__(self, *args, **kwargs):
self.suffix = kwargs.get("suffix", t("messages.reply_suffix"))
super().__init__(*args, **kwargs)
def reply(self, content, *args, **kwargs):
"""|coro|
A helper function that is equivalent to doing
.. code-block:: python
msg = '{0.mention}{1}, {2}'.format(message.author, self.suffix, content)
self.send_message(message.channel, msg, *args, **kwargs)
The following keyword arguments are "extensions" that augment the
behaviour of the standard wrapped call.
def build(self):
game = PongGame()
game.serve_ball()
Clock.schedule_interval(game.update,
1.0 / float(Config.get('frame_limit')))
return game
class PongGame(Widget):
enabled = True
ball = ObjectProperty(None)
player1 = ObjectProperty(None)
player2 = ObjectProperty(None)
game_msg = StringProperty("")
game_msg_expl = StringProperty("")
SCORE_TO_WIN = Config.get('points_to_win')
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)
def clear_game(self):
self.game_msg = ""
self.game_msg_expl = ""
self.player1.score = 0
self.player2.score = 0
def on_touch_down(self, touch):
if not self.enabled:
self.clear_game()
self.enabled = True
def serve_ball(self):
self.ball.center = self.center
self.ball.velocity = Vector(5, 0).rotate(randint(0, 360))
if abs(self.ball.velocity[0]) < abs(self.ball.velocity[1]):
self.ball.velocity = \
Vector(self.ball.velocity[1], self.ball.velocity[0])
def game_end(self, winner):
self.game_msg = "Player {} wins the game!".format(winner)
self.game_msg_expl = "Tap to play again"
self.enabled = False
def update(self, dt):
if not self.enabled:
return
self.ball.move()
self.player1.bounce_ball(self.ball)
self.player2.bounce_ball(self.ball)
if (self.ball.y < 0) or (self.ball.top > self.height):
self.ball.velocity_y *= -1
elif self.ball.x < self.x:
self.player2.score += 1
if self.player2.score == self.SCORE_TO_WIN:
self.game_end(2)
self.serve_ball()
elif self.ball.x > self.width:
self.player1.score += 1
if self.player1.score == self.SCORE_TO_WIN:
self.game_end(1)
self.serve_ball()
