def start(self):
# TODO: recheck listening interface; may need to rebind manager to renewed IP
if 'state_changed_alert' in self.dfm:
raise Exception('An operation is already in progress')
self.dfm['state_changed_alert'] = defer.Deferred()
if not self.torrent and not self.download.metadata:
if self.download.url:
# Don't try to re-fetch until an attempt is done
if self.download.status != Status.LOADING:
if self.download.url.startswith('magnet:'):
params = { 'save_path': str(self.directory), 'auto_managed': True }
resdata = None
if self.download.resume_data:
params['resdata'] = marshal.loads(self.download.resume_data)
self.download.status = Status.LOADING
self.torrent = lt_manager.add_magnet(self, str(self.download.url), params)
self.dfm['metadata_received_alert'] = defer.Deferred()
self.dfm['metadata_received_alert'].addCallback(self.magnet_loaded)
self.dfm['metadata_failed_alert'] = defer.Deferred()
self.dfm['metadata_failed_alert'].addCallback(self.magnet_load_failed)
return self.dfm['state_changed_alert']
else:
self.download.status = Status.LOADING
self.download.status_message = u'Getting the torrent metadata'
client.getPage(str(self.download.url)).addCallback(self.fetch_torrent_success).addErrback(self.fetch_torrent_failure)
return self.dfm['state_changed_alert']
else:
raise Exception('Torrent metadata missing and no source URL specified')
else:
return self.start_real()
def get_page(handler, *args, **kwargs):
deferred = Deferred()
def callback(data):
output = handler(data)
deferred.callback(output)
getPage(*args, **kwargs).addCallback(callback)
return deferred
def collect(self, device, log):
"""Asynchronously collect data from device. Return a deferred."""
log.info("%s: collecting data", device.id)
coresList = getattr(device, 'zSolrCore', None)
if not coresList:
log.error('No zSolrCore property set - please set this for the device')
returnValue(None)
else:
response = {}
#deviceName = device.titleOrId()
deviceName = device.id
for core in coresList:
try:
coresDict = {}
coresDict['name'] = core
coreUrl = 'http://' + deviceName + ':8080/solr/' + core + '/admin/mbeans?stats=true&cat=CORE&key=searcher&ident=true&wt=json'
coreResp = yield getPage(coreUrl)
coreResp = json.loads(coreResp)
coresDict['coreUrl'] = coreResp
replUrl = 'http://' + deviceName + ':8080/solr/' + core + '/admin/mbeans?stats=true&cat=QUERYHANDLER&key=/replication&ident=true&wt=json'
replResp = yield getPage(replUrl)
replResp = json.loads(replResp)
coresDict['replUrl'] = replResp
response[core] = coresDict
except Exception, e:
log.error(
"%s: %s", device.id, e)
#returnValue(None)
continue
#log.info('Response is %s \n' % (response))
returnValue(response)
def GetWeatherInfo(self):
self.url = "http://www.homeys-bunker.de/dm800/feeds/weatherinfo2.php?citycode=%s&metric=%s" % (config.plugins.EVOMC_wi.city.value, config.plugins.EVOMC_wi.metric.value)
try:
getPage(self.url).addCallback(self.UpdateWeatherInfo).addErrback(self.error)
self["CurrentCity"].setText(_("Updating Weather Info ..."))
except Exception, e:
self["CurrentCity"].setText(_("Updating Weather Info failed (Twisted Web not installed)"))
def startRun(self):
if self.weatherPluginEntry is not None:
self["statustext"].text = _("Getting weather information...")
url = "http://weather.service.msn.com/data.aspx?weadegreetype=%s&culture=%s&wealocations=%s" % (self.weatherPluginEntry.degreetype.value, self.language, self.weatherPluginEntry.weatherlocationcode.value)
getPage(url).addCallback(self.xmlCallback).addErrback(self.error)
else:
self["statustext"].text = _("No locations defined...\nPress 'Menu' to do that.")
def filenuke(self, data, url):
#print "drin 2"
id = re.findall('<input type="hidden" name="id".*?value="(.*?)">', data)
fname = re.findall('<input type="hidden" name="fname".*?alue="(.*?)">', data)
post_data = urllib.urlencode({'op': 'download1', 'usr_login': '', 'id': id[0], 'fname': fname[0], 'referer': '', 'method_free': 'Kostenlos'})
#print post_data
getPage(url, method='POST', postdata = post_data, headers={'Content-Type':'application/x-www-form-urlencoded'}).addCallback(self.filenuke_data).addErrback(self.errorload)
def getFromXunlei(result,parameter):
header,tailer,filename = parameter
url = 'http://bt.box.n0808.com/%s/%s/%s' % (header,tailer,filename)
self.transport.write('start downloading from %s\n' % url)
getPage(url,filename).addCallbacks(
ParseTorrent,
lambda result:self.transport.write('download torrent failed\n'))
def GetWeather(self): timeout = config.plugins.AtileHD.refreshInterval.value * 1000 * 60 if timeout > 0: self.timer.start(timeout, True) print "AtileHD lookup for ID " + str(config.plugins.AtileHD.woeid.value) url = "http://query.yahooapis.com/v1/public/yql?q=select%20*%20from%20weather.forecast%20where%20woeid%3D%22"+str(config.plugins.AtileHD.woeid.value)+"%22&format=xml" getPage(url,method = "GET").addCallback(self.GotWeatherData).addErrback(self.downloadError)
def monsteruploads(self, data, url):
if not re.match('.*?eval\(function\(p\,a\,c\,k\,e\,d', data, re.S):
id = re.findall('type="hidden" name="id".*?value="(.*?)"', data, re.S)
fname = re.findall('type="hidden" name="fname".*?value="(.*?)"', data, re.S)
referer = re.findall('type="hidden" name="referer".*?value="(.*?)"', data, re.S)
info = urlencode({
'op': "download2",
'usr_login': "",
'id': id[0],
'fname': fname[0],
'referer': "",
'method_free': "Kostenloser Download"
})
getPage(url, method='POST', postdata = info, headers={'Content-Type':'application/x-www-form-urlencoded'}).addCallback(self.monsteruploads_post).addErrback(self.errorload)
else:
get_packedjava = re.findall("<script type=.text.javascript.>eval.function(.*?)</script>", data, re.S|re.DOTALL)
if get_packedjava:
sJavascript = get_packedjava[1]
sUnpacked = cJsUnpacker().unpackByString(sJavascript)
if sUnpacked:
stream_url = re.findall('type="video/divx"src="(.*?)"', sUnpacked)
if stream_url:
print stream_url[0]
self._callback(stream_url[0])
else:
self.stream_not_found()
else:
self.stream_not_found()
else:
self.stream_not_found()
def render_POST(self, request):
api_key = request.args.get('api_key', [request.getUser()])[0]
if not api_key:
request.setHeader('WWW-Authenticate', 'Basic realm="%s"' % 'notify.io')
errpage = error.ErrorPage(http.UNAUTHORIZED, "Unauthorized", "401 Authentication (API key) required")
return errpage.render(request)
hash = request.path.split('/')[-1].lower()
if not hash or hash == 'notify':
return "No hash"
if not hash in listeners:
listeners[hash] = []
replay = request.args.get('replay', [None])[0]
if replay:
client.getPage(url='%s/notification?hash=%s&api_key=%s&replay=%s' % (NOTIFY_WWW, hash, api_key, replay), method='POST') \
.addCallback(self.notify_success, hash, request) \
.addErrback(self.notify_failure, request)
else:
notification = {}
for arg in ['title', 'text', 'icon', 'link', 'sticky']:
value = request.args.get(arg, [None])[0]
if value:
notification[arg] = value
client.getPage(url='%s/notification?hash=%s&api_key=%s' % (NOTIFY_WWW, hash, api_key), method='POST', postdata=urllib.urlencode(notification)) \
.addCallback(self.notify_success, hash, request) \
.addErrback(self.notify_failure, request)
return server.NOT_DONE_YET
def do_verify(to_verify):
print "Verifying %s as a subscriber to %s" % (to_verify['callback'], to_verify['topic'])
challenge = baseN(abs(hash(time.time())), 36)
verify_token = to_verify.get('verify_token', None)
payload = {'hub.mode': to_verify['mode'], 'hub.topic': to_verify['topic'], 'hub.challenge': challenge}
if verify_token:
payload['hub.verify_token'] = verify_token
url = '?'.join([to_verify['callback'], urllib.urlencode(payload)])
def success(page):
if challenge in page:
if to_verify['mode'] == 'subscribe':
if not to_verify['topic'] in subscriptions:
subscriptions[to_verify['topic']] = []
subscriptions[to_verify['topic']].append(to_verify['callback'])
else:
subscriptions[to_verify['topic']].remove(to_verify['callback'])
if 'onsuccess' in to_verify:
to_verify['onsuccess'](page)
else:
if 'onfail' in to_verify:
to_verify['onfail'](page)
def failure(x):
if 'onfail' in to_verify:
to_verify['onfail'](x)
client.getPage(url).addCallbacks(success, failure)
verify_queue.get().addCallback(do_verify)
def process_message(message, non_main_ns=NON_MAIN_NS, bcast_callback=None):
msg_dict = parse_irc_message(message, non_main_ns)
def broadcast(geo_json=None):
if geo_json is not None:
geo_dict = loads(geo_json)
msg_dict['geo_ip'] = geo_dict
bcast_callback(msg_dict)
def report_failure_broadcast(error):
bcast_log.debug("could not fetch from local geoip: %s", error)
broadcast()
if msg_dict['is_anon']:
if bcast_callback:
try:
geo_url = str(LOCAL_GEOIP + '/json/' + msg_dict['user'])
except UnicodeError:
pass
else:
getPage(geo_url).addCallbacks(callback=broadcast,
errback=report_failure_broadcast)
elif bcast_callback:
broadcast()
return msg_dict
def CheckForMCUpdate(self):
#Get Info from my webserver
try:
getPage(self.url + "currentversion.txt").addCallback(self.GotMCUpdateInfo).addErrback(self.error)
self["text"].setText(_("Checking for updates..."))
except Exception, e:
self["text"].setText(_("Error: Twisted-Web not installed"))
def do_fetch(url):
subscribers = len(subscriptions.get(url, []))
if subscribers:
print "Fetching %s for %s subscribers" % (url, subscribers)
client.getPage(url, headers={'X-Hub-Subscribers': subscribers}) \
.addCallbacks(lambda p: dispatch_queue.put({'topic': url, 'data': p, 'content_type': 'application/atom+xml'}))
fetch_queue.get().addCallback(do_fetch)
def getCookie(self, data=None):
#url = "http://www.skygo.sky.de/index.html"
url = "http://www.skygo.sky.de/skyguide"
msg_log = "get page: '{0}'".format(url)
print msg_log
self.addLog(msg_log)
getPage(url, headers=self.headers1, agent=self.agent, timeout=30, cookies=self.ck).addCallback(self.getSkyGuidePages).addErrback(self.dataError)
def request(self): # if self.serien_name in self.termineCache: # self.__callback(self.termineCache[self.serien_name], False) # else: print "[SerienRecorder] suche ' %s '" % self.serien_name print self.serie_url getPage(getURLWithProxy(self.serie_url), agent=getUserAgent(), headers=getHeaders()).addCallback(self.__callback).addErrback(self.__errback)
def test_start_stop(self):
yield self._storage.put("abc", StringIO("hello world"))
yield self._server.start()
# Starting multiple times is fine.
yield self._server.start()
storage_url = yield self._storage.get_url("abc")
# It might not have started actually accepting connections yet...
yield self.wait_for_server(self._server)
self.assertEqual((yield getPage(storage_url)), "hello world")
# Check that it can be killed by the current user (ie, is not running
# as root) and still comes back up
old_pid = yield self._server.get_pid()
os.kill(old_pid, signal.SIGKILL)
new_pid = yield self._server.get_pid()
self.assertNotEquals(old_pid, new_pid)
# Give it a moment to actually start serving again
yield self.wait_for_server(self._server)
self.assertEqual((yield getPage(storage_url)), "hello world")
yield self._server.stop()
# Stopping multiple times is fine too.
yield self._server.stop()
def handleWebsite(self, website):
info(website.getAttribute("name"))
if self.number[:2] == "00":
number = website.getAttribute("prefix") + self.number.replace(self.countrycode, "")
else:
number = self.number
url = website.getAttribute("url")
if re.search('$AREACODE', url) or re.search('$PFXAREACODE', url):
error("(PFX)ARECODE cannot be handled")
# self.caller = _("UNKNOWN")
self.notifyAndReset()
return
#
# Apparently, there is no attribute called (pfx)areacode anymore
# So, this below will not work.
#
if re.search('\\$AREACODE', url) and website.hasAttribute("areacode"):
areaCodeLen = int(website.getAttribute("areacode"))
url = url.replace("$AREACODE", number[:areaCodeLen]).replace("$NUMBER", number[areaCodeLen:])
elif re.search('\\$PFXAREACODE', url) and website.hasAttribute("pfxareacode"):
areaCodeLen = int(website.getAttribute("pfxareacode"))
url = url.replace("$PFXAREACODE", "%(pfxareacode)s").replace("$NUMBER", "%(number)s")
url = url % {'pfxareacode': number[:areaCodeLen], 'number': number[areaCodeLen:]}
elif re.search('\\$NUMBER', url):
url = url.replace("$NUMBER", "%s") % number
else:
error("cannot handle websites with no $NUMBER in url")
# self.caller = _("UNKNOWN")
self.notifyAndReset()
return
info("Url to query: " + url)
url = url.encode("UTF-8", "replace")
self.currentWebsite = website
getPage(url, agent="Mozilla/5.0 (Windows; U; Windows NT 6.0; de; rv:1.9.0.5) Gecko/2008120122 Firefox/3.0.5").addCallback(self._gotPage).addErrback(self._gotError)
def delete(self):
"""
Delete the specific workflow from VelesForge. Requires write access.
"""
if not self._confirm():
return
print("Deleting %s..." % self.name)
sys.stdout.flush()
def finished(response):
print("Successfully deleted %s" % self.name)
sys.stdout.flush()
self.stop()
def failed(failure):
try:
failure.raiseException()
except:
self.exception("Failed to delete %s:", self.name)
self.stop(failure, False)
url = "%s%s?query=delete&name=%s&token=%s" % (
self.base, root.common.forge.service_name, self.name, self.id)
self.debug("Requesting %s", url)
getPage(url.encode('charmap')).addCallbacks(callback=finished,
errback=failed)
def updateTimer(self):
reactor.callLater(UPDATETIMER, self.updateTimer)
def setTreeStatus(result):
r = json.loads(result)
status = r[u"status"]
treename = r[u"tree"]
changed = False
logmsg = "Regular Tree check says: {} is {}".format(treename, status)
if not treename in self.statusCache:
changed = True
if treename in self.statusCache and status != self.statusCache[treename]:
changed = True
if changed:
# if status previously unknown (= bot has just started)
# or a changed status then set the topic
channel = tree2channel[tree]
topic = "{} is {}!".format(treename, status)
self.topic(channel, topic)
logmsg += ", which is new. changing topic."
print logmsg
else:
logmsg += ", just like before"
print logmsg
self.statusCache[treename] = status
for tree in tree2channel:
url = URL.format(tree)
getPage(url).addCallbacks(callback=setTreeStatus)
def list(self):
"""
Print the list of available workflows on VelesForge.
"""
def finished(response):
self.debug("Received %s", response)
try:
response = json.loads(response.decode('UTF-8'))
except ValueError as e:
self.exception("Failed to parse the response from server: %s",
response)
self.stop(Failure(e), False)
return
table = PrettyTable("Name", "Description", "Author", "Version",
"Date")
table.align["Name"] = table.align["Description"] = 'l'
for item in response:
table.add_row(*item)
print(table)
sys.stdout.flush()
self.stop()
def failed(failure):
self.return_code = 1
try:
failure.raiseException()
except:
self.exception("Failed to list the available models:")
self.stop(failure, False)
url = self.base + root.common.forge.service_name + "?query=list"
self.debug("Requesting %s", url)
getPage(url.encode('charmap')).addCallbacks(callback=finished,
errback=failed)
def __init__(self, session):
Screen.__init__(self, session)
self["info"] = Label('Ładuję...')
self["myPic"] = Pixmap()
try:
os.unlink('/tmp/meteo.png')
except:
pass
self["myActionMap"] = ActionMap(["MeteoActions"],
{
"ok": self.cancel,
"cancel": self.cancel,
"menu": self.menu,
"blue": self.menu,
"green": self.next,
"left": self.prev,
"right": self.next,
"start": self.start,
"info": self.ShowOpis,
"yellow": self.ShowOpis,
"list": self.choose,
}, -1)
getPage('http://e2.areq.eu.org/ummeteo/version').addCallback(self.updateCB).addErrback(self.errorUpdate)
self.onLayoutFinish.append(self.layoutFinished)
def job():
logger.info("Getting page")
txt = yield client.getPage(settings.url)
parsed_txt = html.fromstring(txt)
# pylint:disable=E1102
el = sel_base(parsed_txt)
# if element does not exist
if not len(el):
return
chapter_name = sel_chapter_name(el[0])[0].text.strip()
update_date = sel_update_date(el[0])[0].text.strip()
# do nothing if no new chapter avaliable
if settings.current_chapter == chapter_name:
logger.info("Current chapter is %s, not a new chapter, do nothing.", chapter_name)
return
else:
# saves the new chapter name to settings
settings.current_chapter = chapter_name
data = {
"chapter_name": chapter_name,
"update_date": update_date
}
logger.info("{\n\tchapter_name: %s,\n\tupdate_date: %s\n}", chapter_name, update_date)
logger.info("Sending data to webhook: %s", settings.webhook_url)
try:
yield client.getPage(settings.webhook_url,
method="POST", postdata=json.dumps(data),
headers={"Content-Type": "application/json; chatset=utf-8"})
except Exception as exc:
logger.error("Error occured while sending data.\n%s", str(exc))
else:
logger.info("Data sent")
def listenStreams(self, urlsStream):
"""
@param urlsStream: Definit les url de stream a ecouter
@type urlsStream: tableau d'url
@return : Deferred
Exemple:
lstream = ["http://my.server.org/music.mp3", "http://m.server.org/music2.mp3"]
instanceNabaz.listenStreams(lstreams).addCallback(lambda x: print x)
API Nabastag : ?token=xxx&sn=xxx&urlList=http://my.server.org/music.mp3|http://m.server.org/music2.mp3
"""
paramUrlsStream = '|'.join(urlsStream)
print paramUrlsStream
d = Deferred()
def processedApiResult(result):
d.callback(result)
return d
def processedApiFailed(faillure):
d.errback(faillure)
return d
postdata = {"sn":self.__serialnumber,
"token":self.__tocken,
"urlList":paramUrlsStream}
getPage(self.__urlapi,
method="POST",
postdata=urlencode(postdata),
headers={'Content-Type':'application/x-www-form-urlencoded;\
charset=utf-8'}).addCallback(processedApiResult).addErrback(processedApiFailed)
return d
def recaptcha(self, data):
if data.find('http://goo.gl') != -1:
self.mod.on_recaptcha(self.index, data[data.index('"id"'):].split('"')[3])
else:
self.challenge = data[data.index('challenge'):].split('\'')[1]
url = '{"longUrl": "http://www.google.com/recaptcha/api/image?c=%s"}' % self.challenge
getPage("https://www.googleapis.com/urlshortener/v1/url", method="POST", postdata=url, headers={'Content-Type': 'application/json'}).addCallback(self.recaptcha)
def sendMessage(self, message, voice="FR-Anastasie"):
"""
@param message: send message to nabaztag
@type message: str
@return : Deferred
"""
d = Deferred()
def processedApiResult(result):
d.callback(result)
return d
def processedApiFailed(faillure):
d.errback(faillure)
return d
postdata = {"sn":self.__serialnumber,
"token":self.__tocken,
"tts":message,
"voice":voice}
getPage(self.__urlapi,
method="POST",
postdata=urlencode(postdata),
headers={'Content-Type':'application/x-www-form-urlencoded;\
charset=3Dutf-8'}).addCallback(processedApiResult).addErrback(processedApiFailed)
return d
def start(self):
try:
data = yield getPage("%slogin/" % self.config['url'], cookies=self.cookies)
except Exception:
raise
result = CSRF_RE.search(data)
if not result:
print "error"
return
token = result.group(1)
# login
try:
data = yield getPage("%slogin/" % self.config['url'],
method='POST',
postdata=urllib.urlencode({
'csrfmiddlewaretoken': token,
'username': self.config['username'],
'password': self.config['password'],
}),
cookies=self.cookies,
headers={'Content-Type': 'application/x-www-form-urlencoded'})
except Exception:
raise
self.task = task.LoopingCall(self.update)
self.task.start(self.config["update_rate"])
def _do_fetch_gitrev(build_url, base_url, sourcetarball_url, platform, logger):
result = {}
# get git revision from jenkins
json_all = json.loads((yield _mk_request_jenkins_all_builds(base_url, platform, logger)))
gitrev = None
for i in [i for i in json_all['allBuilds'] if i['url'].encode('ascii', 'ignore') == build_url]:
for fingerprint in i['fingerprint']:
fp_name = fingerprint['original']['name']
if fp_name == 'build-source-tarball-mono':
assert gitrev is None, "should set gitrev only once"
url = sourcetarball_url + str(fingerprint['original']['number']) + '/pollingLog/pollingLog'
if logger:
logger("request: " + str(url))
regexgitrev = re.compile("Latest remote head revision on [a-zA-Z/]+ is: (?P<gitrev>[0-9a-fA-F]+)")
match = regexgitrev.search((yield getPage(url)))
assert match is not None
gitrev = match.group('gitrev')
if fp_name == 'build-source-tarball-mono-pullrequest':
assert gitrev is None, "should set gitrev only once"
url = sourcetarball_url + str(fingerprint['original']['number']) + '/consoleText'
if logger:
logger("request: " + str(url))
regexgitrev = re.compile("GitHub pull request #(?P<prid>[0-9]+) of commit (?P<gitrev>[0-9a-fA-F]+)")
match = regexgitrev.search((yield getPage(url)))
assert match is not None
gitrev = match.group('gitrev')
result[PROPERTYNAME_JENKINSGITHUBPULLREQUEST] = match.group('prid')
assert gitrev is not None, "parsing gitrev failed"
result[PROPERTYNAME_JENKINSGITCOMMIT] = gitrev
defer.returnValue(result)
def openTest(self):
self["info"].setText("Downloading list...")
testno = 1
xurl = "http://www.et-view-support.com/addons/XTA-team/" + self.addon + "/list.txt"
print "xurl =", xurl
getPage(xurl).addCallback(self.gotPage).addErrback(self.getfeedError)
def eco_post(self, data):
url = "http://www.ecostream.tv/assets/js/common.js"
data2 = urllib.urlopen(url).read()
post_url = re.findall("url: '(http://www.ecostream.tv/.*?)\?s=", data2, re.S)
if post_url:
print post_url
sPattern = "var t=setTimeout\(\"lc\('([^']+)','([^']+)','([^']+)','([^']+)'\)"
r = re.findall(sPattern, data)
if r:
for aEntry in r:
sS = str(aEntry[0])
sK = str(aEntry[1])
sT = str(aEntry[2])
sKey = str(aEntry[3])
print "current keys:", sS, sK, sT, sKey
sNextUrl = post_url[0]+"?s="+sS+'&k='+sK+'&t='+sT+'&key='+sKey
print "URL:", sNextUrl
info = urlencode({'s': sS, 'k': sK, 't': sT, 'key': sKey})
print "POST:", info
getPage(sNextUrl, method='POST', postdata=info, headers={'Referer':'http://www.ecostream.tv', 'X-Requested-With':'XMLHttpRequest'}).addCallback(self.eco_final).addErrback(self.errorload)
else:
self.stream_not_found()
else:
self.stream_not_found()
def getSections(self):
self.setStatusLabel("loading sections")
self.loadinginprogress = True
getPage("http://wap.verkehrsinfo.de/wvindex.php3").addCallback(self.sectionsLoaded).addErrback(self.sectionsLoadingFaild)
def getMD5(self):
url = "http://www.dreamboxupdate.com/download/opendreambox/dreambox-nfiflasher-%s-md5sums" % self.box
client.getPage(url).addCallback(self.md5sums_finished).addErrback(
self.feed_failed)
def getItemsOfSection(self, section):
print("loading section", section.name, section.link)
self.setStatusLabel("loading messages "+section.name)
self.loadinginprogress = True
getPage("http://wap.verkehrsinfo.de"+section.link).addCallback(self.trafficitemsLoaded).addErrback(self.trafficitemsLoadingFaild)
def test01(self):
d = client.getPage('https://127.0.0.1:%s/resource' % self.ssl_port)
def check(result):
self.assertEquals('{}', result)
d.addCallback(check)
return d
def nfo_download(self, branch, idx):
nfourl = (self.feedlists[branch][idx][1])[:-4] + ".nfo"
self.nfofilename = (self.feedlists[branch][idx][0])[:-4] + ".nfo"
print "[check_for_NFO]", nfourl
client.getPage(nfourl).addCallback(self.nfo_finished).addErrback(
self.nfo_failed)
def poll(self):
# Reloading, reschedule
if self.reloading:
print("[SimpleRSS] timer triggered while reloading, rescheduling")
self.poll_timer.start(10000, 1)
# End of List
elif len(self.feeds) <= self.current_feed:
# New Items
if self.newItemFeed.history:
print("[SimpleRSS] got new items, calling back")
self.doCallback()
# Inform User
update_notification_value = config.plugins.simpleRSS.update_notification.value
if update_notification_value == "preview":
from .RSSScreens import RSSFeedView
from Tools.Notifications import AddNotificationWithID, RemovePopup
RemovePopup(NOTIFICATIONID)
AddNotificationWithID(
NOTIFICATIONID,
RSSFeedView,
self.newItemFeed,
newItems=True
)
elif update_notification_value == "notification":
AddPopup(
_("Received %d new news item(s).") % (len(self.newItemFeed.history)),
MessageBox.TYPE_INFO,
5,
NOTIFICATIONID
)
elif update_notification_value == "ticker":
from .RSSTickerView import tickerView
if not tickerView:
print("[SimpleRSS] missing ticker instance, something with my code is wrong :-/")
else:
tickerView.display(self.newItemFeed)
# No new Items
else:
print("[SimpleRSS] no new items")
self.current_feed = 0
self.poll_timer.startLongTimer(config.plugins.simpleRSS.interval.value * 60)
# It's updating-time
else:
# Assume we're cleaning history if current feed is 0
clearHistory = self.current_feed == 0
if config.plugins.simpleRSS.update_notification.value != "none":
from Tools import Notifications
if hasattr(Notifications, 'notificationQueue'):
notifications = Notifications.notificationQueue.queue
current_notifications = Notifications.notificationQueue.current
handler = lambda note: (note.fnc, note.screen, note.args, note.kwargs, note.id)
handler_current = lambda note: (note[0].id,)
else:
notifications = Notifications.notifications
current_notifications = Notifications.current_notifications
handler_current = handler = lambda note: note
for x in current_notifications:
if handler_current(x)[0] == NOTIFICATIONID:
print("[SimpleRSS] timer triggered while preview on screen, rescheduling")
self.poll_timer.start(10000, 1)
return
if clearHistory:
for x in notifications:
if handler(x)[4] == NOTIFICATIONID:
print("[SimpleRSS] wont wipe history because it was never read")
clearHistory = False
break
if clearHistory:
del self.newItemFeed.history[:]
# Feed supposed to autoupdate
feed = self.feeds[self.current_feed]
if feed.autoupdate:
getPage(six.ensure_binary(feed.uri)).addCallback(self._gotPage).addErrback(self.error)
# Go to next feed
else:
print("[SimpleRSS] passing feed")
self.next_feed()
def test01_connect(self):
d = client.getPage('http://127.0.0.1:%s/resource' % self.port)
def check(result):
self.assertEquals('true', result)
d.addCallback(check)
return d
def _get_changes(self, url):
return getPage(url, timeout=self.timeout)
def choregraphy(self, choregraphy):
"""
@param choregraphy: describe choregra
@type message: str
@return : Deferred
LED commands
It is a series of values separated by commas.
1. First value : action time (' l'heure ')
("0" if it is the first command).
2. Second value : 'led' , which gives a color to the LED.
3. Third value : To define which LED you want to illuminate.
0 : bottom LED
1 : rabbit's left LED
2 : middle LED
3 : rabbit's right LED
4 : high LED
4. Fourth, Fifth, Sixth value : the color in RGB.
Value from 0 to 255
Ears commands
This is a series of values separated by commas.
The command is as follows :
1. First value : Action time (l'heure)
"0" if it is the first command.
2. Second value : 'motor', to move an ear
3. Third value : Ears command
1 to command left ear
0 to command right ear
4. Fourth value : Angle of ear
Possible value from 0 to 180
5. Fifth value : Unused, set at "0"
6. Sixth value : Rotation of the ears directions
1 : high->back->low->front->high...
0 : high->front->low->back->high...
Exemple :
0,motor,1,20,0,0
0,led,2,0,238,0,2,led,1,250,0,0,3,led,2,0,0,0
10,0,motor,1,20,0,0,0,led,2,0,238,0,2,led,1,250,0,0,3,led,2,0,0,0
"""
d = Deferred()
def processedApiResult(result):
d.callback(result)
return d
def processedApiFailed(faillure):
d.errback(faillure)
return d
postdata = {
"sn": self.__serialnumber,
"token": self.__tocken,
"chor": choregraphy
}
getPage(
self.__urlapi,
method="POST",
postdata=urlencode(postdata),
headers={
'Content-Type':
'application/x-www-form-urlencoded;\
charset=3Dutf-8'
}).addCallback(processedApiResult).addErrback(processedApiFailed)
return d
def _get_page(self, url):
return getPage(url, timeout=self.timeout)
def singlePoll(self, id, callback=False, errorback=None): getPage(six.ensure_binary(self.feeds[id].uri)).addCallback(self._gotPage, id, callback, errorback).addErrback(errorback)
