def listRepo(repo, orderby=None):
"""
listRepo(repo): Get list of all APKs in a specific store from the Aptoide API
and return it in JSON form
"""
file_name = '{0}{1}.json'.format(repo, '' if not orderby else '-' + '-'.join(orderby))
orderby = '' if not orderby else '/orderby/' + '/'.join(orderby)
url = 'http://webservices.aptoide.com/webservices/listRepository/{0}{1}/json'.format(repo, orderby)
data = Debug.readFromFile(file_name)
try:
if data == '':
session = requests.Session()
# session.proxies = Debug.getProxy()
logging.debug('Requesting1: ' + url)
resp = session.get(url)
data = json.loads(resp.text)
Debug.writeToFile(file_name, json.dumps(data, sort_keys=True,
indent=4, separators=(',', ': ')), resp.encoding)
if data['status'] == 'OK':
return data
else:
logging.error(file_name)
except:
logging.exception('!!! Invalid JSON from: "{0}"'.format(url))
return None
def set(cls, key, value, type='string'):
Debug.dprint(text=key)
Debug.dprint(text=value)
if type == 'string':
redis_instance.set(key, value)
elif type == 'list' or type == 'dic':
redis_instance.set(key, json.dumps(value))
def RunCmd(self, command, compReg = True, switchPage = False,
onDone = None):
"""!Run command typed into console command prompt (GPrompt).
@todo Display commands (*.d) are captured and processed
separately by mapdisp.py. Display commands are rendered in map
display widget that currently has the focus (as indicted by
mdidx).
@param command command given as a list (produced e.g. by utils.split())
@param compReg True use computation region
@param switchPage switch to output page
@param onDone function to be called when command is finished
@return 0 on success
@return 1 on failure
"""
if len(command) == 0:
Debug.msg(2, "GPrompt:RunCmd(): empty command")
return 0
# update history file
env = grass.gisenv()
try:
fileHistory = codecs.open(os.path.join(env['GISDBASE'],
env['LOCATION_NAME'],
env['MAPSET'],
'.bash_history'),
encoding = 'utf-8', mode = 'a')
except IOError, e:
self.WriteError(e)
fileHistory = None
def AddOverlay(self, id, type, command,
l_active = True, l_hidden = True, l_opacity = 1.0, l_render = False):
"""!Adds overlay (grid, barscale, legend, etc.) to list of
overlays
@param id overlay id (PseudoDC)
@param type overlay type (barscale, legend)
@param command GRASS command to render overlay
@param l_active overlay activated (True) or disabled (False)
@param l_hidden overlay is not shown in layer tree (if True)
@param l_render render an image (if True)
@return new layer on success
@retutn None on failure
"""
Debug.msg (2, "Map.AddOverlay(): cmd=%s, render=%d" % (command, l_render))
overlay = Overlay(id = id, type = type, cmd = command,
active = l_active, hidden = l_hidden, opacity = l_opacity)
# add maplayer to the list of layers
self.overlays.append(overlay)
if l_render and command != '' and not overlay.Render():
raise gcmd.GException(_("Unable render overlay <%s>.") %
name)
return self.overlays[-1]
def getCardNum(line, key):
rval = ""
Debug().p("line %s key %s" % (line, key))
if line.find(key) != -1:
Debug().p("found %s:%s" % (key, line))
rval = line.split()[0].strip()
return rval
def AlignExtentFromDisplay(self):
"""!Align region extent based on display size from center
point"""
# calculate new bounding box based on center of display
if self.region["ewres"] > self.region["nsres"]:
res = self.region["ewres"]
else:
res = self.region["nsres"]
Debug.msg(3, "Map.AlignExtentFromDisplay(): width=%d, height=%d, res=%f, center=%f,%f" % \
(self.width, self.height, res, self.region['center_easting'],
self.region['center_northing']))
ew = (self.width / 2) * res
ns = (self.height / 2) * res
self.region['n'] = self.region['center_northing'] + ns
self.region['s'] = self.region['center_northing'] - ns
self.region['e'] = self.region['center_easting'] + ew
self.region['w'] = self.region['center_easting'] - ew
# LL locations
if self.projinfo['proj'] == 'll':
self.region['n'] = min(self.region['n'], 90.0)
self.region['s'] = max(self.region['s'], -90.0)
def putArchive(self,choices):
if Specs().s['doArchive']:
try:
Debug().p ("doing archive")
tmpFile="%s/%s"%(Specs().s['tmpdir'],"tarFiles")
cdir=self.cache
textName=cdir+"/"+Specs().s['archiveTextName']
cf=open(textName,"w")
cf.write("%s\n"%choices[0])
cf.write("%s\n"%choices[1])
cf.close()
afiles=glob.glob("%s/*.jpg"%cdir)
tfiles=glob.glob("%s/*.lkp"%cdir)
tf = open(tmpFile,"w")
for file in afiles:
Debug().p ("writing %s to %s"%(file,tmpFile))
fb = os.path.basename(file)
tf.write("%s\n"%fb)
for file in tfiles:
Debug().p("writing %s to %s"%(file,tmpFile))
fb = os.path.basename(file)
tf.write("%s\n"%fb)
tf.close()
cmd = ["tar","-czf",self.adir+"/"+str(uuid.uuid4())+".tgz","-C",cdir,"-T",tmpFile]
Debug().p("cmd %s"%cmd)
subprocess.check_output(cmd)
except subprocess.CalledProcessError, e:
print "Error %s"%(e)
def _renderLayers(self, force, mapWindow):
maps = list()
masks = list()
opacities = list()
# render map layers
ilayer = 1
for layer in self.layers + self.overlays:
# skip non-active map layers
if not layer or not layer.active:
continue
# render
if force or layer.force_render:
if not layer.Render():
continue
if mapWindow:
# update progress bar
### wx.SafeYield(mapWindow)
event = wxUpdateProgressBar(value = ilayer)
wx.PostEvent(mapWindow, event)
# add image to compositing list
if layer.type != "overlay":
maps.append(layer.mapfile)
masks.append(layer.maskfile)
opacities.append(str(layer.opacity))
Debug.msg(3, "Map.Render() type=%s, layer=%s " % (layer.type, layer.name))
ilayer += 1
return maps, masks, opacities
def request_from_url(url, settings):
"""
request_from_url(str)
gets the request from url and returns the requests object
"""
cookies = settings["cookies"]
if cookies["firefox"]:
cj = web.browser_cookie3.firefox()
elif cookies["chrome"]:
cj = web.browser_cookie3.chrome()
elif cookies["opera"]:
cj = web.browser_cookie3.opera()
elif cookies["edge"]:
cj = web.browser_cookie3.edge()
else:
cj = CookieJar()
try:
r = web.requests.get(url,
cookies=cj,
headers={"User-Agent": web.FIREFOX_USER_AGENT},
timeout=settings["connection_timeout"])
except web.requests.ReadTimeout:
Debug.log_file("ConnectionError", "request_from_url",
f"Connection times out on {url}")
r = None
return r
def json_dumps(jdata):
''' dump json string inline '''
try:
return json.dumps(jdata)
except Exception as err:
Debug.error("Error: dump data error: %s" % (err))
return ""
def Draw(self, pdc, img = None, drawid = None, pdctype = 'image', coords = [0,0,0,0]):
"""!Draws histogram or clears window
"""
if drawid == None:
if pdctype == 'image' :
drawid = imagedict[img]
elif pdctype == 'clear':
drawid == None
else:
drawid = wx.NewId()
else:
pdc.SetId(drawid)
pdc.BeginDrawing()
Debug.msg (3, "BufferedWindow.Draw(): id=%s, pdctype=%s, coord=%s" % (drawid, pdctype, coords))
if pdctype == 'clear': # erase the display
bg = wx.WHITE_BRUSH
pdc.SetBackground(bg)
pdc.Clear()
self.Refresh()
pdc.EndDrawing()
return
if pdctype == 'image':
bg = wx.TRANSPARENT_BRUSH
pdc.SetBackground(bg)
bitmap = wx.BitmapFromImage(img)
w,h = bitmap.GetSize()
pdc.DrawBitmap(bitmap, coords[0], coords[1], True) # draw the composite map
pdc.SetIdBounds(drawid, (coords[0],coords[1],w,h))
pdc.EndDrawing()
self.Refresh()
def urlsToImages(urls):
cdir = Archive().clearArchive()
imageCount = 0
images = []
for url in urls:
Debug().p("url:%s" % url)
imageTypes = ['full', 'thumb']
raw_img = None
for t in imageTypes:
try:
Debug().p("open image type: %s image: %s" % (t, url[t]))
response = requests.get(url[t], timeout=20)
raw_img = response.content
break
except Exception as e:
traceback.print_exc()
print "return from exception for type %s url %s: %s" % (
t, url[t], e)
continue
if raw_img != None:
fname = "%s/urlimage%d.jpg" % (cdir, imageCount)
imageCount += 1
f = open(fname, "wb")
f.write(raw_img)
f.close()
images.append(fname)
return images
def make_image(self, images):
d.dbg('Broxton.make_image: {}'.format(images))
make_sh = None
for image in images:
d.dbg('create makesh for {}'.format(image))
if type(image) is dict:
if 'mmm' in image:
make_sh = self.create_mmm_sh(image['mmm'])
else:
d.err('Not support: %s' % str(image))
exit()
else:
make_sh = self.create_make_sh(image)
# set run right
cmd = r'chmod a+x {}'.format(make_sh)
subprocess.call(cmd, shell=True)
# run make sh
cmd = r'./{}'.format(make_sh)
d.dbg(cmd)
subprocess.call(cmd, shell=True)
# delete make sh
cmd = r'rm -rf {}'.format(make_sh)
d.dbg(cmd)
subprocess.call(cmd, shell=True)
def _get_components(self):
''' query components, the result like:
{
"Statistics": "ACTIVE",
"Billing": "ACTIVE",
"LocationDataStream": "ACTIVE",
...
}
'''
cmd = r'fdsinstall -u Setup -p Earth_#10 -s'
data = os.popen(cmd).read()
if not data:
Debug.error("query components state error: %s" % cmd)
return None
# parse state
lines = data.split('\n')
components = {}
for line in lines:
# FSC-Event/4.1/linux-eagle-32/1 ACTIVE linux-eagle-32
pattern = r'([^/]*)\/(\d\.\d)\/([^/]*)\/(\d)\s*(\w+)\s+'
matchObj = re.match(pattern, line)
if matchObj:
components[matchObj.group(1)] = matchObj.group(5)
# components[matchObj.group(1)] = {
# "Version": matchObj.group(2),
# "State": matchObj.group(5)
# }
return components
def __init__(self, data=None, size=2**10):
self.data = data if data else [r_uint32(0)] * (size >> 2)
self.size = r_uint(len(self.data) << 2)
self.debug = Debug()
# TODO: pass data_section to memory for bounds checking
self.data_section = 0x00000000
def json_dumps4(jdata):
''' dump json string with pretty format '''
try:
return json.dumps(jdata, indent=4)
except Exception as err:
Debug.error("Error: dump data error: %s" % (err))
return ""
def DeleteLayer(self, layer, overlay = False):
"""!Removes layer from list of layers
@param layer layer instance in layer tree
@param overlay delete overlay (use self.DeleteOverlay() instead)
@return removed layer on success or None
"""
Debug.msg (3, "Map.DeleteLayer(): name=%s" % layer.name)
if overlay:
list = self.overlays
else:
list = self.layers
if layer in list:
if layer.mapfile:
base = os.path.split(layer.mapfile)[0]
mapfile = os.path.split(layer.mapfile)[1]
tempbase = mapfile.split('.')[0]
if base == '' or tempbase == '':
return None
basefile = os.path.join(base, tempbase) + r'.*'
for f in glob.glob(basefile):
os.remove(f)
list.remove(layer)
return layer
return None
def OnLeftUp(self, event):
"""!Left mouse button released
"""
Debug.msg (5, "BufferedWindow.OnLeftUp(): use=%s" % \
self.mouse["use"])
self.mouse['end'] = event.GetPositionTuple()[:]
if self.mouse['use'] in ["zoom", "pan"]:
# set region in zoom or pan
begin = self.mouse['begin']
end = self.mouse['end']
if self.mouse['use'] == 'zoom':
# set region for click (zero-width box)
if begin[0] - end[0] == 0 or \
begin[1] - end[1] == 0:
# zoom 1/2 of the screen (TODO: settings)
begin = (end[0] - self.Map.width / 4,
end[1] - self.Map.height / 4)
end = (end[0] + self.Map.width / 4,
end[1] + self.Map.height / 4)
self.Zoom(begin, end, self.zoomtype)
# redraw map
self.UpdateMap(render=True)
# update statusbar
self.parent.StatusbarUpdate()
def __init__(self, constant_zero=True, num_regs=32):
self.num_regs = num_regs
self.regs = [0] * self.num_regs
self.debug = Debug()
if constant_zero: self._setitemimpl = self._set_item_const_zero
else: self._setitemimpl = self._set_item
def getApkInfo(repo, apkid, apkversion, options=None, doVersion1=False):
"""
getApkInfo(repo, apkid, apkversion): Get APK specific information from the Aptoide API
and return it in JSON form
"""
version = '1' if doVersion1 else '2'
file_name = '{0}-{1}-{2}_{3}.json'.format(repo, apkid, apkversion, version)
options = '' if not options else '/options=({0})'.format(options)
url = 'http://webservices.aptoide.com/webservices/{0}/getApkInfo/{1}/{2}/{3}{4}/json'.format(
version, repo, apkid, apkversion, options)
data = Debug.readFromFile(file_name)
try:
if data == '':
session = requests.Session()
# session.proxies = Debug.getProxy()
logging.debug('Requesting2: ' + url)
resp = session.get(url)
data = json.loads(resp.text)
Debug.writeToFile(file_name, json.dumps(data, sort_keys=True,
indent=4, separators=(',', ': ')), resp.encoding)
if data['status'] == 'OK':
return data
else:
logging.error(file_name)
except:
logging.exception('!!! Invalid JSON from: "{0}"'.format(url))
return None
def _poweroff(self):
"""
Log on to remote node and shut it down.
:rtype: str
:returns: Status message
"""
host = request.args.get('host')
if host is None:
message = "Error 'poweroff' must have parameter 'host'!"
return self._json_response(message, 400)
if host in self.API_POWEROFF_HOSTS.keys():
user = self.API_POWEROFF_HOSTS[host]['user']
else:
message = "Error host '{}' has not been configured for 'poweroff'!"
message = message.format(host)
return self._json_response(message, 400)
# Power off node
command = ("{}ssh -o 'StrictHostKeyChecking no' -i {} -T {}@{} 'shutdo"
"wn -h now'")
ssh_key_file = self.SSH_KEY_FILE.replace('$HOST', host)
command = command.format(self.SSH_PATH, ssh_key_file, user, host)
Debug.debug_print(1, 'Shut down command: {}'.format(command))
p = subprocess.Popen(
command, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
shell=True)
stdout, stderr = p.communicate()
message = codecs.decode(stdout + stderr, 'utf-8')
return self._json_response(message, 200)
def getVersionInfo(apkVersionInfo):
"""
getVersionInfo(apkVersionInfo): Determines each versions information
"""
html_name = apkVersionInfo.scrape_url.rsplit('/', 2)[1]
html_name = html_name.replace('-android-apk-download', '') + '.html'
url = APKMIRRORBASEURL + apkVersionInfo.scrape_url
html = Debug.readFromFile(html_name)
if html == '':
session = requests.Session()
logging.debug('Requesting3: ' + url)
resp = session.get(url)
html = unicodedata.normalize('NFKD', resp.text).encode('ascii', 'ignore')
Debug.writeToFile(html_name, html, resp.encoding)
try:
dom = BeautifulSoup(html, 'html5lib')
postArea = dom.findAll('div', {'class': 'post-area'})[0]
dl_button = postArea.findAll('a', {'type': 'button'})[1]
blueFonts = postArea.findAll('span', {'class': 'fontBlue'})
apkVersionInfo.download_url = dl_button['href']
for blueFont in blueFonts:
if blueFont.get_text() == 'File name: ':
apkVersionInfo.apk_name = blueFont.next_sibling
if blueFont.get_text() == 'Version: ':
apkVersionInfo.ver = blueFont.next_sibling
except:
logging.exception('!!! Error parsing html from: "{0}"'.format(url))
def run(self):
stime = time.time()
while SoundFile().testBumpCollection():
try:
#print (self.name,"time",time.time(),"stime",stime)
if time.time() > stime:
entry = SoundFile().getSoundEntry()
Debug().p ("player choosing %s "%entry)
count = 0
for t in self.tList:
choice = entry[count]
count += 1
if count == len(entry):
count = 0
Debug().p ("sending %s to %s"%(choice,t.name))
t.setCurrentSound(choice)
offset = random.randint(Specs().s['minChange'],Specs().s['maxChange'])
stime = time.time() + offset
Debug().p ("next change: %d"%offset)
n = pygame.mixer.get_busy()
Debug().p ("number busy channels %d"%n)
time.sleep(1)
except Exception as e:
print("player error: "+repr(e))
os._exit(3)
for t in self.tList:
t.stop()
self.done = True
def printText(self, t):
self.clear()
Debug().p("%s panel 0 %s len %s" % (self.name, t[0], len(t[0])))
self.ser.write('{0: ^16}'.format(t[0]).upper())
Debug().p("%s panel 1 %s len %s" % (self.name, t[1], len(t[1])))
self.setRow(1)
self.ser.write('{0: ^16}'.format(t[1]).upper())
def sysex(self,msg):
Debug().p("sysex got msg %s"%msg)
if self.setupState == "RequestSceneData":
self.scene = sysex_to_data(msg.data[12:])
for l in self.desc['soundLists']:
for s in l:
self.soundList.append(s)
maxSounds = len(self.soundList)
maxSounds &= 0x7f
for y in range(0,8):
for x in NanoPlayer.togLocs:
self.scene[x+(y*31)] = 1
maxNotes = 48
self.scene[NanoPlayer.sliderMaxLoc+(y*31)] = maxNotes
self.scene[NanoPlayer.knobMaxLoc+(y*31)] = maxSounds
for x in NanoPlayer.transTogs:
self.scene[x] = 1
retData = data_to_sysex(self.scene)
header = []
for c in range(0,12):
header.append(msg.data[c])
for rd in retData:
header.append(rd)
self.sendSysex(header)
self.setupState = "ConfigDataSent"
elif self.setupState == "ConfigDataSent":
if msg.data[7] != 35:
print("MIDI ERROR: config did not succeed")
self.setupState == None
elif self.setupState == None:
Debug().p("%s unexepected sysex message: %s"%(self.name,msg))
def checkOneApp(self, apkid):
"""
checkOneApp(apkid):
"""
logging.info('Checking app: {0}'.format(apkid))
filenames = []
url = 'http://apk-dl.com/' + apkid
session = requests.Session()
logging.debug('Requesting: ' + url)
resp = session.get(url)
html = unicodedata.normalize('NFKD', resp.text).encode('ascii', 'ignore')
try:
dom = BeautifulSoup(html, 'html5lib')
apklist = dom.findAll('ul', {'class': 'apks dlist'})[0]
apks = apklist.findAll('div', {'class': 'details'})
for apk in apks:
items = apk.findAll('div')
dApk = {}
for item in items:
itext = '{0}'.format(item.get_text().encode('ascii', 'ignore'))
itext = re.sub('\s', '', itext)
itextsp = itext.split(':', 1)
if len(itextsp) == 2:
dApk[str(itextsp[0])] = str(itextsp[1])
apkurl = apk.find('a', {'class': 'btn btn-success'})
if apkurl:
dApk['url'] = 'http:' + apkurl['href']
Debug.printDictionary(dApk)
if 'Version' in dApk and 'RequiresAndroid' in dApk:
(trash, sdk) = dApk['RequiresAndroid'].split('API:', 1)
sdk = sdk[0:-1]
(ver, vercode) = dApk['Version'].split('(Code:', 1)
ver = ver.split('(', 1)[0].strip()
vercode = vercode[0:-1].strip()
avi = ApkVersionInfo(name=apkid,
sdk=sdk,
ver=ver,
vercode=vercode,
download_src=dApk['url'],
crawler_name=self.__class__.__name__
)
if self.report.isThisApkNeeded(avi):
filenames.append(self.downloadApk(avi))
except IndexError:
logging.info('{0} not supported by apk-dl.com ...'.format(apkid))
except:
logging.exception('!!! Error parsing html from: "{0}"'.format(url))
return filenames
def __init__(self, url=URL):
super(Cwp, self).__init__(url)
self._url = url
# create cmd process
self._cmdHdrs = CmdProcessing()
self._cmdHdrs.register_cmd_handler(self.get_cmd_handlers())
d.dbg('Cwp init done!')
def getRunNameInDirForMutable(self, run_dir, mutable, slope=''):
gradient = str(mutable.name)
if(slope):
gradient += str(slope)
run_name = self.run_name_in_dir.format(
run_dir=run_dir, this=self, gradient=gradient)
Debug.log('run_name: ' + run_name)
return run_name
def startDownload(driver):
driver.get(Config.Base_Url + Config.Target_Name + Config.Category)
Debug.log('fbPA:' + Config.Base_Url + Config.Target_Name + Config.Category)
Debug.sc_shot(driver, '2-Albums Index.png')
html_source = (driver.page_source).encode('utf-8')
getAllAlbumsInfo(driver, html_source)
startDownloadAlbumsPhoto(driver)
def startDownload(driver):
driver.get( Config.Base_Url + Config.Target_Name + Config.Category)
Debug.log('fbPA:'+ Config.Base_Url + Config.Target_Name + Config.Category)
Debug.sc_shot(driver,'2-Albums Index.png')
html_source = (driver.page_source).encode('utf-8')
getAllAlbumsInfo(driver, html_source)
startDownloadAlbumsPhoto(driver)
def calculate(self, cur_run_file):
'''determine the value of each run'''
# Get data to compare
self._cost = self._getData(cur_run_file)
# Apply the weight to the cost function
self._cost *= self.__weight
Debug.log('cost: {0}'.format(self._cost), False)
return self._cost
def _onMouseMoving(self, event):
self.mouse['end'] = event.GetPositionTuple()[:]
Debug.msg (5, "BufferedWindow.OnMouseMoving(): coords=%f,%f" % \
(self.mouse['end'][0], self.mouse['end'][1]))
action = self.toolbar.GetAction()
if action == "addLine" and \
self.toolbar.GetAction('type') in ["line", "boundary", "area"]:
if len(self.polycoords) > 0:
self.MouseDraw(pdc = self.pdcTmp, begin = self.Cell2Pixel(self.polycoords[-1]))
elif action in ["moveLine", "moveVertex", "editLine"] \
and hasattr(self, "moveInfo"):
dx = self.mouse['end'][0] - self.mouse['begin'][0]
dy = self.mouse['end'][1] - self.mouse['begin'][1]
# draw lines on new position
if action == "moveLine" and \
len(self.moveInfo['id']) > 0:
# move line
for id in self.moveInfo['id']:
self.pdcTmp.TranslateId(id, dx, dy)
elif action in ["moveVertex", "editLine"]:
# move vertex ->
# (vertex, left vertex, left line,
# right vertex, right line)
# do not draw static lines
if action == "moveVertex" and \
len(self.moveInfo['id']) > 0:
self.polycoords = []
self.pdcTmp.RemoveId(self.moveInfo['id'][0])
if self.moveInfo['id'][1] > 0: # previous vertex
x, y = self.Pixel2Cell(self.pdcTmp.GetIdBounds(self.moveInfo['id'][1])[0:2])
self.pdcTmp.RemoveId(self.moveInfo['id'][1] + 1)
self.polycoords.append((x, y))
self.polycoords.append(self.Pixel2Cell(self.mouse['end']))
if self.moveInfo['id'][2] > 0: # next vertex
x, y = self.Pixel2Cell(self.pdcTmp.GetIdBounds(self.moveInfo['id'][2])[0:2])
self.pdcTmp.RemoveId(self.moveInfo['id'][2]-1)
self.polycoords.append((x, y))
self.ClearLines(pdc = self.pdcTmp)
self.DrawLines(pdc = self.pdcTmp)
if action == "editLine":
self.MouseDraw(pdc = self.pdcTmp,
begin = self.Cell2Pixel(self.polycoords[-1]))
self.Refresh() # TODO: use RefreshRect()
self.mouse['begin'] = self.mouse['end']
elif action == "zbulkLine":
if len(self.polycoords) == 1:
# draw mouse moving
self.MouseDraw(self.pdcTmp)
def json_parse(data):
''' parse json string '''
try:
if not data:
return {}
return json.loads(data)
except Exception as err:
Debug.error("Error: parse data (%.25s...) error: %s" % (data, err))
return {}
def ChangeLayerName (self, layer, name):
"""!Change name of the layer
@param layer layer instance in layer tree
@param name layer name to set up
"""
Debug.msg (3, "Map.ChangeLayerName(): from=%s to=%s" % \
(layer.name, name))
layer.name = name
def __init__(self, constant_zero=True, num_regs=32, nbits=32):
self.num_regs = num_regs
self.regs = [r_uint(0)] * self.num_regs
self.debug = Debug()
self.nbits = nbits
self.debug_nchars = nbits / 4
if constant_zero: self._setitemimpl = self._set_item_const_zero
else: self._setitemimpl = self._set_item
def next(self):
Debug().p(self.recog.name + " in dataStream next")
chunk = self.recog.queue.get()
if type(chunk) is str and chunk == "__stop__":
print("%s stopping" % self.recog.name)
self.recog.running = false
raise StopIteration
Debug().p(self.recog.name + " got:" + str(len(chunk)))
return chunk
def help(self, cmds):
for cmd in cmds:
if cmd == 'help':
d.info('repo:[init][,sync|fsync]')
d.info(' init : repo init source code')
d.info(' sync : repo sync source code')
d.info(' fsync: repo sync source code with -f')
elif cmd == 'cfg':
d.info('url: {}'.format(self._url))
def ChangeLayerActive(self, layer, active):
"""!Enable or disable map layer
@param layer layer instance in layer tree
@param active to be rendered (True)
"""
layer.active = active
Debug.msg (3, "Map.ChangeLayerActive(): name='%s' -> active=%d" % \
(layer.name, layer.active))
def repo_handler(self, cmds):
d.dbg('repo_handler: %s' % cmds)
for cmd in cmds:
if cmd == 'init':
self.repo_init()
elif cmd == 'sync':
self.repo_sync()
elif cmd == 'fsync':
self.repo_sync(True)
def find_handler(self, cmds):
d.dbg('find_handler: {}'.format(cmds))
try:
n = len(cmds)
if n == 1:
self.find('./', cmds[0])
elif n >= 2:
self.find(cmds[0], cmds[1])
except KeyError as e:
d.err('Error: %s' % e)
class _SparseMemory( object ):
_immutable_fields_ = [ "BlockMemory", "block_size", "addr_mask",
"block_mask" ]
def __init__( self, BlockMemory, block_size=2**10 ):
self.BlockMemory = BlockMemory
self.block_size = block_size
self.addr_mask = block_size - 1
self.block_mask = 0xffffffff ^ self.addr_mask
self.debug = Debug()
print "sparse memory size %x addr mask %x block mask %x" \
% ( self.block_size, self.addr_mask, self.block_mask )
#blocks = []
self.block_dict = {}
def add_block( self, block_addr ):
#print "adding block: %x" % block_addr
self.block_dict[ block_addr ] = self.BlockMemory( size=self.block_size )
@elidable
def get_block_mem( self, block_addr ):
#block_idx = block_dict[
if block_addr not in self.block_dict:
self.add_block( block_addr )
block_mem = self.block_dict[ block_addr ]
return block_mem
@elidable
def iread( self, start_addr, num_bytes ):
start_addr = hint( start_addr, promote=True )
num_bytes = hint( num_bytes, promote=True )
block_addr = self.block_mask & start_addr
block_mem = self.get_block_mem( block_addr )
return block_mem.iread( start_addr & self.addr_mask, num_bytes )
def read( self, start_addr, num_bytes ):
if self.debug.enabled( "mem" ):
print ':: RD.MEM[%s] = ' % pad_hex( start_addr ),
block_addr = self.block_mask & start_addr
block_addr = hint( block_addr, promote=True )
block_mem = self.get_block_mem( block_addr )
value = block_mem.read( start_addr & self.addr_mask, num_bytes )
if self.debug.enabled( "mem" ):
print '%s' % pad_hex( value ),
return value
def write( self, start_addr, num_bytes, value ):
if self.debug.enabled( "mem" ):
print ':: WR.MEM[%s] = %s' % ( pad_hex( start_addr ),
pad_hex( value ) ),
block_addr = self.block_mask & start_addr
block_addr = hint( block_addr, promote=True )
block_mem = self.get_block_mem( block_addr )
block_mem.write( start_addr & self.addr_mask, num_bytes, value )
def run(self):
print("%s starting" % self.name)
self.setRunning(SoundFile().testBumpCollection())
loop = Specs().s['musicLoop']
while self.isRunning():
if self.checkMsg():
continue
entry = SoundFile().getSoundEntry()
Debug().p("player choosing %s" % entry)
count = 0
if self.musicBlocks[Hosts().getLocalHost()].mute:
Debug().p("%s local %s mute so ignoring" %
(self.name, Hosts().getLocalHost()))
else:
for t in SoundTrackManager().eventThreads:
choice = random.choice(entry)
Debug().p("sending %s request to %s" % (choice, t.name))
t.setCurrentSound(choice)
for ip in self.musicBlocks.keys():
if Hosts().isLocalHost(ip):
Debug().p("%s: ignoring %s" % (self.name, ip))
continue
if self.musicBlocks[ip].mute:
Debug().p("%s: ignoring muted %s %s" %
(self.name, ip, self.musicBlocks[ip].mute))
continue
try:
url = "http://" + ip + ":8080"
Debug().p("%s: url: %s" % (self.name, url))
cmd = {'cmd': "Sound", 'args': choice}
req = urllib2.Request(url, json.dumps(cmd),
{'Content-Type': 'application/json'})
timeout = 1
f = urllib2.urlopen(req, None, timeout)
test = f.read()
Debug().p("%s: got response:%s" % (self.name, test))
except urllib2.URLError as ve:
Debug().p("%s: got URLError %s on ip:%s" %
(self.name, ve, ip))
continue
except Exception as e:
print("%s got exception %s" % (self.name, e))
continue
self.waitTime = random.randint(Specs().s['minChange'],
Specs().s['maxChange'])
Debug().p("next change: %d" % self.waitTime)
#Debug().p("number busy channels %d"%n
if SoundFile().testBumpCollection() is False:
print "waiting for channels to be done"
n = pygame.mixer.get_busy()
while n != 0:
n = pygame.mixer.get_busy()
print "number busy channels", n
if self.checkMsg():
continue
if loop:
SoundFile().setCurrentCollection(self.collection)
else:
self.SetRunning(false)
self.doExit()
def __init__( self, BlockMemory, block_size=2**10 ):
self.BlockMemory = BlockMemory
self.block_size = block_size
self.addr_mask = block_size - 1
self.block_mask = 0xffffffff ^ self.addr_mask
self.debug = Debug()
print "sparse memory size %x addr mask %x block mask %x" \
% ( self.block_size, self.addr_mask, self.block_mask )
#blocks = []
self.block_dict = {}
self.debug = Debug()
def checkOneApp(apkid):
"""
checkOneApp(apkid):
"""
dAllApks = Global.dAllApks
maxVerEachApk = Global.maxVerEachApk
minSdkEachApk = Global.minSdkEachApk
logging.info("Checking app: {0}".format(apkid))
file_name = "{0}.json".format(apkid)
url = "http://helper.mgccw.com/nclient/sjson/detail/detailInfo.htm?apkId=" + apkid
data = Debug.readFromFile(file_name)
try:
if data == "":
session = requests.Session()
# session.proxies = Debug.getProxy()
logging.debug("Requesting: " + url)
resp = session.get(url, allow_redirects=False)
if (resp.status_code) == 302:
raise ValueError
data = json.loads(resp.text)
Debug.writeToFile(
file_name, json.dumps(data, sort_keys=True, indent=4, separators=(",", ": ")), resp.encoding
)
item = data["data"]["appInfo"]
if not filter(lambda apk: apk.vercode == item["versionCode"], dAllApks[apkid]):
v = item["version"].split(" ")[0]
maxApkInfo = ApkVersionInfo(name=item["apkId"], ver=maxVerEachApk[item["apkId"]])
tmpApkInfo = ApkVersionInfo(name=item["apkId"], ver=v)
# Is it >= maxVersion
if maxApkInfo <= tmpApkInfo:
thisSdk = int(item["sdkVersion"])
if thisSdk < minSdkEachApk[item["apkId"]]:
logging.debug("SdkTooLow: {0}({1})".format(item["apkId"], thisSdk))
else:
downloadApk(
"http://download.mgccw.com/" + item["apkPath"],
item["apkId"],
item["version"],
item["versionCode"],
item["sdkVersion"],
)
# END: if Sdk
# END: if item
except ValueError:
logging.info("{0} not supported by mobogenie ...".format(apkid))
except:
logging.exception('!!! Invalid JSON from: "{0}"'.format(url))
def get_all_hough_lines(image, min_angle, max_angle, min_separation_distance,
min_separation_angle):
angles = np.deg2rad(np.arange(min_angle, max_angle, 0.5))
hough, angles, distances = hough_line(image, angles)
Debug.save_image("hough", "accumulator", normalize(hough))
_, peak_angles, peak_distances = \
hough_line_peaks(hough, angles, distances,
num_peaks=150,
threshold=0.2*np.amax(hough),
min_distance=min_separation_distance,
min_angle=min_separation_angle)
lines = [
get_line_endpoints_in_image(image, angle, radius)
for angle, radius in zip(peak_angles, peak_distances)
]
if Debug.active:
peak_angle_idxs = [
np.where(angles == angle)[0][0] for angle in peak_angles
]
peak_rho_idxs = [
np.where(distances == distance)[0][0]
for distance in peak_distances
]
peak_coords = zip(peak_rho_idxs, peak_angle_idxs)
peaks = np.zeros(hough.shape)
for coord in peak_coords:
peaks[coord] = 1
Debug.save_image("hough", "accumulator_peaks", peaks)
if Record.active:
# Thought get_max_theta_idx might be a useful way to filter
# real meanlines from spurious meanlines, but it's not
# reliable when the image is saturated with incorrect
# meanlines. Filtering lines based on the ROI angle
# was more effective.
# max_theta_idx = get_max_theta_idx(hough)
# Record.record("theta_mode", angles[max_theta_idx])
# in radians
average_meanline_angle = np.mean(peak_angles)
std_deviation_meanline_angle = np.std(peak_angles)
Record.record("average_meanline_angle",
float("%.4f" % average_meanline_angle))
Record.record("std_deviation_meanline_angle",
float("%.4f" % std_deviation_meanline_angle))
return lines
def base64decode(data):
''' base64 decode string '''
try:
val = base64.b64decode(data).decode("UTF-8")
if val is not None:
if type(val) == str:
return val
return val.decode("UTF-8")
except Exception as err:
Debug.error("Error: b64decode data (%.25s...) error: %s" % (data, err))
return ""
def on_stop_mock(self):
"""
Stop button is pressed
"""
if is_android:
Globals.mock_thread.send_message("stop")
else:
# Set a random location on Windows or Linux
Debug.randomize_latlng()
self.mockmapview.update_current_locmarker(Debug.latitude, Debug.longitude, False)
self.mockmapview.remove_target_marker()
def get(cls, handler, name):
session = SessionManager(handler)
Debug.dprint(text='name: ' + name, type='custom')
Debug.dprint(text='value: ' + str(session.get(name)), type='error')
# print "Session name is: " + name
# print "Do we have a session? " + str(session.get(name))
# if cls.exists(handler, name):
# print "There is a session"
# else:
# print "There is not any sessionn"
return session.get(name)
def SetCmd(self, cmd):
"""!Set new command for layer"""
if self.type == 'command':
self.cmd = []
for c in cmd:
self.cmd.append(utils.CmdToTuple(c))
else:
self.cmd = utils.CmdToTuple(cmd)
Debug.msg(3, "Layer.SetCmd(): cmd='%s'" % self.GetCmd(string = True))
# for re-rendering
self.force_render = True
def startDownloadAlbumsPhoto(driver):
for index, item in enumerate(AlbumsInfoList):
driver.get( Config.Base_Url + Config.Target_Name + '/media_set?set=' + AlbumsInfoList[index].albums_link)
Debug.sc_shot(driver,'3-AlbumsPhoto.png')
html_source = (driver.page_source).encode('utf-8')
# Create folder
folder_path = r'./' + Config.Folder_name + '/' + cleanFolderName(item.albums_name)
if not os.path.exists(folder_path):
os.makedirs(folder_path)
getAllAlbumsPhoto(driver, html_source, folder_path)
break
def ChangeOpacity(self, layer, l_opacity):
"""!Changes opacity value of map layer
@param layer layer instance in layer tree
@param l_opacity opacity level <0;1>
"""
# l_opacity must be <0;1>
if l_opacity < 0: l_opacity = 0
elif l_opacity > 1: l_opacity = 1
layer.opacity = l_opacity
Debug.msg (3, "Map.ChangeOpacity(): layer=%s, opacity=%f" % \
(layer.name, layer.opacity))
def ReorderLayers(self, layerList):
"""!Reorder list to match layer tree
@param layerList list of layers
"""
self.layers = layerList
layerNameList = ""
for layer in self.layers:
if layer.name:
layerNameList += layer.name + ','
Debug.msg (4, "Map.ReoderLayers(): layers=%s" % \
(layerNameList))
def __InitDisplay(self):
"""
Initialize map display, set dimensions and map region
"""
self.width, self.height = self.GetClientSize()
Debug.msg(2, "MapFrame.__InitDisplay():")
self.grwiz.SwitchEnv('source')
self.SrcMap.ChangeMapSize(self.GetClientSize())
self.SrcMap.region = self.SrcMap.GetRegion() # g.region -upgc
self.grwiz.SwitchEnv('target')
self.TgtMap.ChangeMapSize(self.GetClientSize())
self.TgtMap.region = self.TgtMap.GetRegion() # g.region -upgc
class RegisterFile( object ):
def __init__( self, constant_zero=True, num_regs=32, nbits=32 ):
self.num_regs = num_regs
self.regs = [ r_uint(0) ] * self.num_regs
self.debug = Debug()
self.nbits = nbits
self.debug_nchars = nbits / 4
if constant_zero: self._setitemimpl = self._set_item_const_zero
else: self._setitemimpl = self._set_item
def __getitem__( self, idx ):
if self.debug.enabled( "rf" ):
print ':: RD.RF[%s] = %s' % (
pad( "%d" % idx, 2 ),
pad_hex( self.regs[idx],
len=self.debug_nchars ) ),
return self.regs[idx]
@specialize.argtype(2)
def __setitem__( self, idx, value ):
value = r_uint( value )
self._setitemimpl( idx, value )
def _set_item( self, idx, value ):
self.regs[idx] = value
if self.debug.enabled( "rf" ):
print ':: WR.RF[%s] = %s' % (
pad( "%d" % idx, 2 ),
pad_hex( self.regs[idx],
len=self.debug_nchars ) ),
def _set_item_const_zero( self, idx, value ):
if idx != 0:
self.regs[idx] = value
if self.debug.enabled( "rf" ):
print ':: WR.RF[%s] = %s' % (
pad( "%d" % idx, 2 ),
pad_hex( self.regs[idx],
len=self.debug_nchars ) ),
#-----------------------------------------------------------------------
# print_regs
#-----------------------------------------------------------------------
# prints all registers (register dump)
# per_row specifies the number of registers to display per row
def print_regs( self, per_row=6 ):
for c in xrange( 0, self.num_regs, per_row ):
str = ""
for r in xrange( c, min( self.num_regs, c+per_row ) ):
str += "%s:%s " % ( pad( "%d" % r, 2 ),
pad_hex( self.regs[r], len=(self.nbits/4) ) )
print str
class _ByteMemory( object ):
def __init__( self, data=None, size=2**10 ):
self.data = data if data else [' '] * size
self.size = len( self.data )
self.debug = Debug()
def bounds_check( self, addr ):
# check if the accessed data is larger than the memory size
if addr > self.size:
print "WARNING: accessing larger address than memory size. " + \
"addr=%s size=%s" % ( pad_hex( addr ), pad_hex( self.size ) )
if addr == 0:
print "WARNING: writing null pointer!"
raise Exception()
@unroll_safe
def read( self, start_addr, num_bytes ):
if self.debug.enabled( "memcheck" ):
self.bounds_check( start_addr )
value = 0
if self.debug.enabled( "mem" ):
print ':: RD.MEM[%s] = ' % pad_hex( start_addr ),
for i in range( num_bytes-1, -1, -1 ):
value = value << 8
value = value | ord( self.data[ start_addr + i ] )
if self.debug.enabled( "mem" ):
print '%s' % pad_hex( value ),
return value
# this is instruction read, which is otherwise identical to read. The
# only difference is the elidable annotation, which we assume the
# instructions are not modified (no side effects, assumes the addresses
# correspond to the same instructions)
@elidable
def iread( self, start_addr, num_bytes ):
value = 0
for i in range( num_bytes-1, -1, -1 ):
value = value << 8
value = value | ord( self.data[ start_addr + i ] )
return value
@unroll_safe
def write( self, start_addr, num_bytes, value ):
if self.debug.enabled( "memcheck" ):
self.bounds_check( start_addr )
if self.debug.enabled( "mem" ):
print ':: WR.MEM[%s] = %s' % ( pad_hex( start_addr ),
pad_hex( value ) ),
for i in range( num_bytes ):
self.data[ start_addr + i ] = chr(value & 0xFF)
value = value >> 8
def UpdateHist(self, img = None):
"""!Update canvas if histogram options changes or window
changes geometry
"""
Debug.msg (2, "BufferedWindow.UpdateHist(%s): render=%s" % (img, self.render))
oldfont = ""
oldencoding = ""
if self.render:
# render new map images
# set default font and encoding environmental variables
if "GRASS_FONT" in os.environ:
oldfont = os.environ["GRASS_FONT"]
if self.parent.font != "": os.environ["GRASS_FONT"] = self.parent.font
if "GRASS_ENCODING" in os.environ:
oldencoding = os.environ["GRASS_ENCODING"]
if self.parent.encoding != None and self.parent.encoding != "ISO-8859-1":
os.environ[GRASS_ENCODING] = self.parent.encoding
# using active comp region
self.Map.GetRegion(update = True)
self.Map.width, self.Map.height = self.GetClientSize()
self.mapfile = self.Map.Render(force = self.render)
self.img = self.GetImage()
self.resize = False
if not self.img: return
try:
id = self.imagedict[self.img]
except:
return
# paint images to PseudoDC
self.pdc.Clear()
self.pdc.RemoveAll()
self.Draw(self.pdc, self.img, drawid = id) # draw map image background
self.resize = False
# update statusbar
# Debug.msg (3, "BufferedWindow.UpdateHist(%s): region=%s" % self.Map.region)
self.Map.SetRegion()
self.parent.statusbar.SetStatusText("Image/Raster map <%s>" % self.parent.mapname)
# set default font and encoding environmental variables
if oldfont != "":
os.environ["GRASS_FONT"] = oldfont
if oldencoding != "":
os.environ["GRASS_ENCODING"] = oldencoding
def EncodeString(string):
"""!Return encoded string using system locales
@param string string to be encoded
@return encoded string
"""
if not string:
return string
enc = locale.getdefaultlocale()[1]
if enc:
Debug.msg(5, "EncodeString(): enc=%s" % enc)
return string.encode(enc)
return string
def __init__( self, data=None, size=2**10 ):
self.data = data if data else [ r_uint32(0) ] * (size >> 2)
self.size = (len( self.data ) << 2)
self.debug = Debug()
# TODO: pass data_section to memory for bounds checking
self.data_section = 0x00000000
def downloadApk(url,package,vercode):
"""
downloadApk(apkInfo): Download the specified URL to APK file name
"""
apkname = '{0}-{1}.apk'.format(package,
vercode)
logging.info('Downloading "{0}" from: {1}'.format(apkname,url))
try:
if os.path.exists(apkname):
logging.info('Downloaded APK already exists.')
return
if os.path.exists(os.path.join('.', 'apkcrawler', apkname)):
logging.info('Downloaded APK already exists (in ./apkcrawler/).')
return
if os.path.exists(os.path.join('..', 'apkcrawler', apkname)):
logging.info('Downloaded APK already exists (in ../apkcrawler/).')
return
# Open the url
session = requests.Session()
session.proxies = Debug.getProxy()
r = session.get(url,stream=True)
with open(apkname, 'wb') as local_file:
for chunk in r.iter_content(1024):
local_file.write(chunk)
print('{0} '.format(apkname)),
sys.stdout.flush()
except OSError:
logging.exception('!!! Filename is not valid: "{0}"'.format(apkname))
