def on_clicked(self):
# capture parameters
self.file_name = self.filename_comboBox.currentText()
self.calc_year = self.period_comboBox.currentText()
# create wrapper with current parameters
self.wr = Wrapper(self.file_name, self.calc_year)
self.wr.onclick_calculate()
def get_private_report(self,
username,
a_token,
report_name,
report_pass,
flag=''):
wrapper = Wrapper(self.host, self.port)
if not wrapper.check_connection():
cquit(Status.DOWN, "Backend connection error!")
Report = {
'Name': report_name,
'Password': report_pass,
'Type': 'private'
}
result, errno = wrapper.view_report(username, a_token, Report)
if errno == err.VIEW_REPORT_SUCCESS:
if flag != '':
if flag not in result['Data']:
cquit(Status.CORRUPT, "Flag in report is not valid!")
else:
if flag == '':
cquit(Status.MUMBLE, "Could not get private report!")
else:
cquit(Status.CORRUPT, "Could not get private report!")
def save_private_report(self, username, a_token, report_name, report_pass,
flag):
wrapper = Wrapper(self.host, self.port)
if not wrapper.check_connection():
cquit(Status.DOWN, "Backend connection error!")
report_data = report_template % (random.randint(
100, 1000), username, str(round(
time.time())), 'private', random.randint(100, 1000), flag)
Report = {
'Name': report_name,
'Type': 'private',
'Password': report_pass,
'Data': report_data
}
result, errno = wrapper.save_report(username, a_token, Report)
if errno == err.REPORT_NOT_SAVED:
cquit(Status.MUMBLE, "Could not save private report!")
if errno != err.SAVE_REPORT_SUCCESS:
cquit(Status.MUMBLE, "Could not save private report!")
def __init__(self, parent = None, settings_path = ""):
super(ScudCloud, self).__init__(parent)
self.setWindowTitle('ScudCloud')
self.settings_path = settings_path
self.notifier = Notifier(Resources.APP_NAME, Resources.get_path('scudcloud.png'))
self.settings = QSettings(self.settings_path + '/scudcloud.cfg', QSettings.IniFormat)
self.identifier = self.settings.value("Domain")
if Unity is not None:
self.launcher = Unity.LauncherEntry.get_for_desktop_id("scudcloud.desktop")
else:
self.launcher = DummyLauncher(self)
self.webSettings()
self.leftPane = LeftPane(self)
webView = Wrapper(self)
webView.page().networkAccessManager().setCookieJar(self.cookiesjar)
self.stackedWidget = QtGui.QStackedWidget()
self.stackedWidget.addWidget(webView)
centralWidget = QtGui.QWidget(self)
layout = QtGui.QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.addWidget(self.leftPane)
layout.addWidget(self.stackedWidget)
centralWidget.setLayout(layout)
self.setCentralWidget(centralWidget)
self.addMenu()
self.tray = Systray(self)
self.systray(ScudCloud.minimized)
self.installEventFilter(self)
if self.identifier is None:
webView.load(QtCore.QUrl(Resources.SIGNIN_URL))
else:
webView.load(QtCore.QUrl(self.domain()))
webView.show()
def __init__(self, window, builder, reddit_info, use_stylesheet=True):
self.window = window
self.builder = builder
if use_stylesheet:
filename = 'style.css'
style = Gtk.CssProvider()
with open(filename, 'r') as file:
cssData = file.read().encode()
style.load_from_data(cssData)
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(), style,
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
self.random_tmp = ''.join(
random.choice(string.ascii_uppercase + string.digits)
for i in range(6))
self.directory = '/tmp/cobreddit_' + self.random_tmp
if not os.path.exists(self.directory):
os.makedirs(self.directory)
self.reddit = Wrapper(reddit_info)
self.builder.connect_signals({
"destroy": self.onDestroy,
"viewSub": self.view_sub
})
self.setup_stack()
self.view_sub('aww')
def send_mail_to_support_payment(self, orderid, extrordid=None):
# tsm_mail_list = [str(SysConst().Get_Sys_Const("byvladislav")), str(SysConst().Get_Sys_Const("stanly.solano")), str(SysConst().Get_Sys_Const("zanoga.maxim")), str(SysConst().Get_Sys_Const("dimitriy.shevchenko"))]
tsm_mail_list = (str(
SysConst().Get_Sys_Const("support_mail"))).split(',')
customer_info = self.get_customer_info_by_order(orderid)[0]
order_info = self.w.select("*", self.table_orders,
"where id={0}".format(orderid))[0]
for x in tsm_mail_list:
###send_mail(self.tsm_mail_address, self.tsm_mail_pass, self.tsm_mail_address, x,"Order has been PAID! [ {0} ]".format(self.site_name), "","Order ID: {0}<br>UID: {4}<br>Client mail: {1}<br>First name: {2}<br>Last name: {3}<br><br>Price: <strong>${5}</strong><br>DeadLine: <strong>{6}</strong>".format(orderid,customer_info.get('email'),customer_info.get('first_name'),customer_info.get('last_name'),order_info.get('uid'),order_info.get('price'),order_info.get('deadline')))
if extrordid:
wrap = Wrapper()
extra_price = Extraorders(wrap).get_surcharge_paid(extrordid)
msg = "Hello Support!<br>Order ID: {0}, Extra Order ID: {7}<br>UID: {4}<br>Client mail: {1}<br>First name: {2}<br>Last name: {3}<br><br>Extra price: <strong>${5}</strong><br>DeadLine: <strong>{6}</strong>".format(
orderid, customer_info.get('email'),
str(customer_info.get('first_name')).lower().title(),
str(customer_info.get('last_name')).lower().title(),
order_info.get('uid'),
extra_price[0].get('final_order_surcharge'),
order_info.get('deadline'), str(extrordid))
else:
msg = "Hello Support!<br>Order ID: {0}<br>UID: {4}<br>Client mail: {1}<br>First name: {2}<br>Last name: {3}<br><br>Price: <strong>${5}</strong><br>DeadLine: <strong>{6}</strong>".format(
orderid, customer_info.get('email'),
str(customer_info.get('first_name')).lower().title(),
str(customer_info.get('last_name')).lower().title(),
order_info.get('uid'), order_info.get('price'),
order_info.get('deadline'))
msg_send = TemlateLetter().get_template_letter(
"", "", msg, "Customer", self.site_mail, self.site_name)
send_mail(self.tsm_mail_address, self.tsm_mail_pass,
self.tsm_mail_address, x,
"Order has been PAID! [ {0} ]".format(self.site_name),
"", msg_send)
def browser():
driver = webdriver.Chrome(ChromeDriverManager().install())
driver.maximize_window()
driver.get("http://localhost/phpmyadmin/index.php")
browser = Wrapper(driver)
yield browser
driver.quit()
def _PostRepoUpgrade(manifest, quiet=False):
wrapper = Wrapper()
if wrapper.NeedSetupGnuPG():
wrapper.SetupGnuPG(quiet)
for project in manifest.projects:
if project.Exists:
project.PostRepoUpgrade()
def _CheckWrapperVersion(ver, repo_path):
if not repo_path:
repo_path = '~/bin/repo'
if not ver:
print('no --wrapper-version argument', file=sys.stderr)
sys.exit(1)
exp = Wrapper().VERSION
ver = tuple(map(int, ver.split('.')))
if len(ver) == 1:
ver = (0, ver[0])
exp_str = '.'.join(map(str, exp))
if exp[0] > ver[0] or ver < (0, 4):
print("""
!!! A new repo command (%5s) is available. !!!
!!! You must upgrade before you can continue: !!!
cp %s %s
""" % (exp_str, WrapperPath(), repo_path), file=sys.stderr)
sys.exit(1)
if exp > ver:
print("""
... A new repo command (%5s) is available.
... You should upgrade soon:
cp %s %s
""" % (exp_str, WrapperPath(), repo_path), file=sys.stderr)
def _PostRepoFetch(rp, repo_verify=True, verbose=False):
if rp.HasChanges:
print('info: A new version of repo is available', file=sys.stderr)
wrapper = Wrapper()
try:
rev = rp.bare_git.describe(rp.GetRevisionId())
except GitError:
rev = None
_, new_rev = wrapper.check_repo_rev(rp.gitdir, rev, repo_verify=repo_verify)
# See if we're held back due to missing signed tag.
current_revid = rp.bare_git.rev_parse('HEAD')
new_revid = rp.bare_git.rev_parse('--verify', new_rev)
if current_revid != new_revid:
# We want to switch to the new rev, but also not trash any uncommitted
# changes. This helps with local testing/hacking.
# If a local change has been made, we will throw that away.
# We also have to make sure this will switch to an older commit if that's
# the latest tag in order to support release rollback.
try:
rp.work_git.reset('--keep', new_rev)
except GitError as e:
sys.exit(str(e))
print('info: Restarting repo with latest version', file=sys.stderr)
raise RepoChangedException(['--repo-upgraded'])
else:
print('warning: Skipped upgrade to unverified version', file=sys.stderr)
else:
if verbose:
print('repo version %s is current' % rp.work_git.describe(HEAD),
file=sys.stderr)
def Execute(self, opt, args):
rp = self.manifest.repoProject
rem = rp.GetRemote(rp.remote.name)
branch = rp.GetBranch('default')
# These might not be the same. Report them both.
src_ver = RepoSourceVersion()
rp_ver = rp.bare_git.describe(HEAD)
print('repo version %s' % rp_ver)
print(' (from %s)' % rem.url)
print(' (tracking %s)' % branch.merge)
print(' (%s)' % rp.bare_git.log('-1', '--format=%cD', HEAD))
if self.wrapper_path is not None:
print('repo launcher version %s' % self.wrapper_version)
print(' (from %s)' % self.wrapper_path)
if src_ver != rp_ver:
print(' (currently at %s)' % src_ver)
print('repo User-Agent %s' % user_agent.repo)
print('git %s' % git.version_tuple().full)
print('git User-Agent %s' % user_agent.git)
print('Python %s' % sys.version)
uname = platform.uname()
if sys.version_info.major < 3:
# Python 3 returns a named tuple, but Python 2 is simpler.
print(uname)
else:
print('OS %s %s (%s)' % (uname.system, uname.release, uname.version))
print('CPU %s (%s)' %
(uname.machine, uname.processor if uname.processor else 'unknown'))
print('Bug reports:', Wrapper().BUG_URL)
def newUser(self):
pubk = self.exportRSAPublicKey()
salt = bcrypt.gensalt()
(ccmodulus, ccexponent) = self.CCgetExponentAndModulus()
dealer = Wrapper()
dealer.login()
bi = dealer.getBI()
dealer.logout()
serverPubKey = requests.get(
"http://localhost:3030/getServerPublicRSAKey")
if serverPubKey.content == '':
print 'No server public key'
return
serverPubKey = RSA.importKey(
base64.urlsafe_b64decode(serverPubKey.content))
hashed = self.hashNsalt(self.RSApassphrase, salt)
hashed = cipherModule.processObjectRSA(hashed, serverPubKey)
hashed = base64.urlsafe_b64encode(hashed)
requests.get("http://localhost:3030/addUser?userID=" + self.userName +
'&userBI=' + bi + '&pubKey=' + pubk + '&passwordHS=' +
hashed + '&salt=' + salt + '&ccmodulus=' + ccmodulus +
'&ccexponent=' + ccexponent,
verify=False)
def loginCC(self):
r = requests.get("http://localhost:3030/getCCChallenge?userID=" +
self.userName)
challenge = (r.content)
dealer = Wrapper()
dealer.login()
certChain = dealer.getCertificateChain()
challengeSigned = dealer.sign(challenge.decode('hex'))
dealer.logout()
certChain = ';;:.:;;'.join(certChain)
certChain = base64.urlsafe_b64encode(certChain)
response = requests.get(
"http://localhost:3030/authenticateCC?challengeSigned=" +
challengeSigned + '&userID=' + self.userName + '&certChain=' +
certChain)
if response.content == '1':
print 'User Authenticated!'
self.getSessionKey()
self.loginb = 1
else:
print 'User not Authenticated!'
self.loginb = 0
def __init__(self):
cooridor_width = 5
cooridor_height = 5
squares = []
for i in range(cooridor_width):
new_square = [int(cooridor_height / 2), i]
squares.append(new_square)
features_sq = [{
'color': "grey",
'reward': 0,
'squares': squares
}, {
'color':
"red",
'reward':
10,
'squares': [[int(cooridor_height / 2), cooridor_width - 1]]
}]
self.env = Grid(cooridor_height,
cooridor_width,
gamma=0.9,
white_r=-1,
features_sq=features_sq,
start_corner=False,
end_pos=(int(cooridor_height / 2), cooridor_width - 1))
self.policy = self.init_policy()
self.agent = Agent(self.policy, self.env.nS, self.env.nA)
self.wrapper = Wrapper(self.env, self.agent, log=True)
def PrintAllCommandsBody(self):
print('The complete list of recognized repo commands is:')
commandNames = list(sorted(all_commands))
self._PrintCommands(commandNames)
print("See 'repo help <command>' for more information on a "
'specific command.')
print('Bug reports:', Wrapper().BUG_URL)
def addWrapper(self, url):
webView = Wrapper(self)
webView.page().networkAccessManager().setCookieJar(self.cookiesjar)
webView.page().networkAccessManager().setCache(self.diskCache)
webView.load(QtCore.QUrl(url))
webView.show()
self.stackedWidget.addWidget(webView)
self.stackedWidget.setCurrentWidget(webView)
def version_tuple(self):
global _git_version
if _git_version is None:
_git_version = Wrapper().ParseGitVersion()
if _git_version is None:
print('fatal: unable to detect git version', file=sys.stderr)
sys.exit(1)
return _git_version
def load_config():
try:
with open(DB_CONFIG) as f:
config = json.load(f)
except IOError as err:
print('Cannot load configuration file. Exiting application \n', str(err))
sys.exit(1)
return Wrapper(config)
def version_tuple(self):
global _git_version
if _git_version is None:
ver_str = git.version()
_git_version = Wrapper().ParseGitVersion(ver_str)
if _git_version is None:
print('fatal: "%s" unsupported' % ver_str, file=sys.stderr)
sys.exit(1)
return _git_version
def __init__(self, database, dir_path, debug=False):
self._parser = Parser()
self._wrapper = Wrapper()
self._writer = Writer(database)
self._sitemap_generator = SitemapGenerator(database)
self._feeds_generator = FeedsGenerator(database)
self._debug = debug
self._dir_path = dir_path
self._database = database
self._file_path = ""
def request(self, flow):
if "Wrapper" in flow.request.headers and flow.request.headers[
'Wrapper'] == '1':
wrapper = Wrapper()
result = wrapper.getData()
# (token, sessid) = wrapper.getData()
# flow.request.text = re.sub(r'_token=[a-zA-Z0-9]+', '_token=%s' % token, flow.request.text)
# flow.request.cookies['roundcube_sessid'] = sessid
del flow.request.headers['Wrapper']
ctx.log.info('Wrapper No1 done!')
def baseline(env, agent, num_samples, n_episodes, horizon):
wrapper = Wrapper(env, agent, log=True)
total_r, trajectories = wrapper.eval_episodes(n_episodes, horizon=horizon)
#trajectories = np.array(trajectories, dtype=int)
#indices = np.random.choice(len(trajectories), num_samples)
#samples = trajectories[indices]
#return list(samples)
samples = (sample(trajectories,num_samples))
return samples
def _CheckWrapperVersion(ver_str, repo_path):
"""Verify the repo launcher is new enough for this checkout.
Args:
ver_str: The version string passed from the repo launcher when it ran us.
repo_path: The path to the repo launcher that loaded us.
"""
# Refuse to work with really old wrapper versions. We don't test these,
# so might as well require a somewhat recent sane version.
# v1.15 of the repo launcher was released in ~Mar 2012.
MIN_REPO_VERSION = (1, 15)
min_str = '.'.join(str(x) for x in MIN_REPO_VERSION)
if not repo_path:
repo_path = '~/bin/repo'
if not ver_str:
print('no --wrapper-version argument', file=sys.stderr)
sys.exit(1)
# Pull out the version of the repo launcher we know about to compare.
exp = Wrapper().VERSION
ver = tuple(map(int, ver_str.split('.')))
exp_str = '.'.join(map(str, exp))
if ver < MIN_REPO_VERSION:
print("""
repo: error:
!!! Your version of repo %s is too old.
!!! We need at least version %s.
!!! A new version of repo (%s) is available.
!!! You must upgrade before you can continue:
cp %s %s
""" % (ver_str, min_str, exp_str, WrapperPath(), repo_path),
file=sys.stderr)
sys.exit(1)
if exp > ver:
print('\n... A new version of repo (%s) is available.' % (exp_str, ),
file=sys.stderr)
if os.access(repo_path, os.W_OK):
print("""\
... You should upgrade soon:
cp %s %s
""" % (WrapperPath(), repo_path),
file=sys.stderr)
else:
print("""\
... New version is available at: %s
... The launcher is run from: %s
!!! The launcher is not writable. Please talk to your sysadmin or distro
!!! to get an update installed.
""" % (WrapperPath(), repo_path),
file=sys.stderr)
def search_user(self, username, a_token):
wrapper = Wrapper(self.host, self.port)
if not wrapper.check_connection():
cquit(Status.DOWN, "Backend connection error!")
result, errno = wrapper.search_user(username, a_token, username[0:5])
if errno != err.SEARCH_NAME_SUCCESS:
cquit(Status.MUMBLE, "Backend: Could not find user!")
def global_handler(self, connection, event):
p = Wrapper(self, connection, event, config, util)
event_handled = False
# tell all modules that this event has fired
for module in self.modules:
# a module returning True means it declares it's handled the
# event and no further events should be handled (aside from
# the global handler)
event_handled = module.handle_event(event_handled, p)
def get_item(self):
"""
"""
try:
context_dict = Wrapper(self)
except Exception, e:
etype = sys.exc_info()[0]
tb = pprint.pformat(traceback.format_tb(sys.exc_info()[2]))
return 'ERROR: exception wrapping object: %s: %s\n%s' % (etype, str(e),
tb)
def __init__(self, host="localhost", port=7496, id=1):
self.host = host
self.port = port
self.id = id
self.subscriptions = {}
self.subscriptionCounter = 1
wrapper = Wrapper()
self.client = EClientSocket(wrapper)
self.client.eConnect(host, port, id)
time.sleep(5)
def Execute(self, opt, args):
git_require(MIN_GIT_VERSION_HARD, fail=True)
if not git_require(MIN_GIT_VERSION_SOFT):
print(
'repo: warning: git-%s+ will soon be required; please upgrade your '
'version of git to maintain support.' %
('.'.join(str(x) for x in MIN_GIT_VERSION_SOFT), ),
file=sys.stderr)
opt.quiet = opt.output_mode is False
opt.verbose = opt.output_mode is True
rp = self.manifest.repoProject
# Handle new --repo-url requests.
if opt.repo_url:
remote = rp.GetRemote('origin')
remote.url = opt.repo_url
remote.Save()
# Handle new --repo-rev requests.
if opt.repo_rev:
wrapper = Wrapper()
remote_ref, rev = wrapper.check_repo_rev(
rp.gitdir,
opt.repo_rev,
repo_verify=opt.repo_verify,
quiet=opt.quiet)
branch = rp.GetBranch('default')
branch.merge = remote_ref
rp.work_git.reset('--hard', rev)
branch.Save()
if opt.worktree:
# Older versions of git supported worktree, but had dangerous gc bugs.
git_require((2, 15, 0),
fail=True,
msg='git gc worktree corruption')
self._SyncManifest(opt)
self._LinkManifest(opt.manifest_name)
if self.manifest.manifestProject.config.GetBoolean(
'repo.superproject'):
self._CloneSuperproject(opt)
if os.isatty(0) and os.isatty(1) and not self.manifest.IsMirror:
if opt.config_name or self._ShouldConfigureUser(opt):
self._ConfigureUser(opt)
self._ConfigureColor()
self._DisplayResult(opt)
def __init__(self):
self.env = Grid(5,
5,
0.9,
white_r=-1,
gen_features="random",
noise=0.0,
n_features=3,
weights="random",
start_corner=False)
self.policy = self.init_policy()
self.agent = Agent(self.policy, self.env.nS, self.env.nA)
self.wrapper = Wrapper(self.env, self.agent, log=False)
def __init__(self):
self.env = Grid(9,
9,
0.9,
white_r=-1,
gen_features="random",
noise=0.0,
n_features=8,
weights="random",
start_corner=True,
one_hot=True)
self.policy = self.init_policy()
self.agent = Agent(self.policy, self.env.nS, self.env.nA)
self.wrapper = Wrapper(self.env, self.agent, log=True)