X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~yarrgweb/git?p=ypp-sc-tools.main.git;a=blobdiff_plain;f=yoweb-scrape;h=90a5677c50e3ff1b1a01fb5427d98ff5ebf564ca;hp=3ef87609e0d268087a07055557c4446dfc5646f1;hb=bb6f3057cff743f25c2ef95a734b9c0f05c97ff6;hpb=612318e7d3e87d2373943fc13d8a9b9ab29f4aae

diff --git a/yoweb-scrape b/yoweb-scrape
index 3ef8760..90a5677 100755
--- a/yoweb-scrape
+++ b/yoweb-scrape
@@ -44,6 +44,7 @@ import random
 import curses
 import termios
 import random
+import subprocess
 from optparse import OptionParser
 from StringIO import StringIO
 
@@ -98,22 +99,25 @@ def format_time_interval(ti):
 	if ti < 86400: return '%dh' % (ti / 3600)
 	return '%dd' % (ti / 86400)
 
+def yppsc_dir():
+	lib = os.getenv("YPPSC_YARRG_SRCBASE")
+	if lib is not None: return lib
+	lib = sys.argv[0] 
+	lib = regexp.sub('/[^/]+$', '', lib)
+	os.environ["YPPSC_YARRG_SRCBASE"] = lib
+	return lib
+
 #---------- caching and rate-limiting data fetcher ----------
 
 class Fetcher:
-	def __init__(self, ocean, cachedir):
+	def __init__(self, cachedir):
 		debug('Fetcher init %s' % cachedir)
-		self.ocean = ocean
 		self.cachedir = cachedir
 		try: os.mkdir(cachedir)
 		except (OSError,IOError), oe:
 			if oe.errno != errno.EEXIST: raise
 		self._cache_scan(time.time())
 
-	def default_ocean(self, ocean='ice'):
-		if self.ocean is None:
-			self.ocean = ocean
-
 	def _cache_scan(self, now):
 		# returns list of ages, unsorted
 		ages = []
@@ -195,12 +199,38 @@ class Fetcher:
 		debug('Fetcher  stored')
 		return data
 
+class Yoweb(Fetcher):
+	def __init__(self, ocean, cachedir):
+		debug('Yoweb init %s' % cachedir)
+		self.ocean = ocean
+		Fetcher.__init__(self, cachedir)
+
+	def default_ocean(self, ocean='ice'):
+		if self.ocean is None:
+			self.ocean = ocean
+
 	def yoweb(self, kind, tail, max_age):
 		self.default_ocean()
+		assert(self.ocean)
 		url = 'http://%s.puzzlepirates.com/yoweb/%s%s' % (
 			self.ocean, kind, tail)
 		return self.fetch(url, max_age)
 
+class Yppedia(Fetcher):
+	def __init__(self, cachedir):
+		debug('Yoweb init %s' % cachedir)
+		self.base = 'http://yppedia.puzzlepirates.com/'
+		self.localhtml = opts.localhtml
+		Fetcher.__init__(self, cachedir)
+
+	def __call__(self, rhs):
+		if self.localhtml is None:
+			url = self.base + rhs
+			debug('Yppedia retrieving YPP '+url);
+			return self.fetch(url, 3000)
+		else:
+			return file(opts.localhtml + '/' + rhs, 'r')
+
 #---------- logging assistance for troubled screenscrapers ----------
 
 class SoupLog:
@@ -377,6 +407,309 @@ class CrewInfo(SomethingSoupInfo):
 	def __str__(self):
 		return `(self.crew, self.msgs)`
 
+class FlagInfo(SomethingSoupInfo):
+	# Public data members (after init):
+	#
+	#   name	#		string
+	#
+	#   relations[n] = (otherflagname, otherflagid, [stringfromyoweb],
+	#		thisdeclaring, otherdeclaringmin, otherdeclaringmax)
+	#		# where {this,other}declaring{,min,max} are:
+	#		#	-1	{this,other} is declaring war
+	#		#	 0	{this,other} is not doing either
+	#		#	+1	{this,other} is allying
+	#   relation_byname[otherflagname] = relations[some_n]
+	#   relation_byid[otherflagname] = relations[some_n]
+	#
+	#   islands[n] = (islandname, islandid)
+	#
+	def __init__(self, flagid, max_age=600):
+		SomethingSoupInfo.__init__(self,
+			'flag/info.wm?flagid=', flagid, max_age)
+		self._find_flag()
+
+	def _find_flag(self):
+		font2 = self._soup.find('font',{'size':'+2'})
+		self.name = font2.find('b').contents[0]
+
+		self.relations = [ ]
+		self.relation_byname = { }
+		self.relation_byid = { }
+		self.islands = [ ]
+
+		magnate = self._soup.find('img',{'src':
+			'/yoweb/images/repute-MAGNATE.png'})
+		warinfo = (magnate.findParent('table').findParent('tr').
+			findNextSibling('tr').findNext('td',{'align':'left'}))
+
+		def warn(m):
+			print >>sys.stderr, 'WARNING: '+m
+
+		def wi_warn(head, waritem):
+			warn('unknown warmap item: %s: %s' % 
+				(`head`, ``waritem``))
+
+		def wihelp_item(waritem, thing):
+			url = waritem.get('href', None)
+			if url is None:
+				return ('no url for '+thing,None,None)
+			m = regexp.search('\?'+thing+'id=(\d+)$', url)
+			if not m: return ('no '+thing+'id',None,None)
+			tid = m.group(1)
+			tname = waritem.string
+			if tname is None:
+				return (thing+' name not just string',None,None)
+			return (None,tid,tname)
+
+		def wi_alwar(head, waritem, thisdecl, othermin, othermax):
+			(err,flagid,flagname) = wihelp_item(waritem,'flag')
+			if err: return err
+			rel = self.relation_byid.get(flagid, None)
+			if rel: return 'flag id twice!'
+			if flagname in self.relation_byname:
+				return 'flag name twice!'
+			rel = (flagname,flagid,head, thisdecl,othermin,othermax)
+			self.relations.append(rel)
+			self.relation_byid[flagid] = rel
+			self.relation_byname[flagid] = rel
+
+		def wi_isle(head, waritem):
+			(err,isleid,islename) = wihelp_item(waritem,'island')
+			if err: return err
+			self.islands.append((isleid,islename))
+
+		warmap = {
+			'Allied with':			(wi_alwar,+1,+1,+1),
+			'Declaring war against':	(wi_alwar,-1, 0,+1),
+			'At war with':			(wi_alwar,-1,-1,-1),
+			'Trying to form an alliance with': (wi_alwar,+1,-1,0),
+			'Islands controlled by this flag': (wi_isle,),
+			}
+
+		how = (wi_warn, None)
+
+		for waritem in warinfo.findAll(['font','a']):
+			if waritem is None: break
+			if waritem.name == 'font':
+				colour = waritem.get('color',None)
+				if colour.lstrip('#') != '958A5F':
+					warn('strange colour %s in %s' %
+						(colour,``waritem``))
+					continue
+				head = waritem.string
+				if head is None:
+					warn('no head string in '+``waritem``)
+					continue
+				head = regexp.sub('\\s+', ' ', head).strip()
+				head = head.rstrip(':')
+				how = (head,) + warmap.get(head, (wi_warn,))
+				continue
+			assert(waritem.name == 'a')				
+
+			debug('WARHOW %s(%s, waritem, *%s)' %
+				(how[1], `how[0]`, `how[2:]`))
+			bad = how[1](how[0], waritem, *how[2:])
+			if bad:
+				warn('bad waritem %s: %s: %s' % (`how[0]`,
+					bad, ``waritem``))
+
+	def __str__(self):
+		return `(self.name, self.islands, self.relations)`
+
+#---------- scraper for ocean info incl. embargoes etc. ----------
+
+class IslandBasicInfo():
+	# Public data attributes:
+	#  ocean
+	#  name
+	# Public data attributes maybe set by caller:
+	#  arch
+	def __init__(self, ocean, islename):
+		self.ocean = ocean
+		self.name = islename
+	def yppedia(self):
+		def q(x): return urllib.quote(x.replace(' ','_'))
+		url_rhs = q(self.name) + '_(' + q(self.ocean) + ')'
+		return yppedia(url_rhs)
+	def __str__(self):
+		return `(self.ocean, self.name)`
+
+class IslandExtendedInfo(IslandBasicInfo):
+	# Public data attributes (inherited):
+	#  ocean
+	#  name
+	# Public data attributes (additional):
+	#  islandid
+	#  yoweb_url
+	#  flagid
+	def __init__(self, ocean, islename):
+		IslandBasicInfo.__init__(self, ocean, islename)
+		self.islandid = None
+		self.yoweb_url = None
+		self._collect_yoweb()
+		self._collect_flagid()
+
+	def _collect_yoweb(self):
+		debug('IEI COLLECT YOWEB '+`self.name`)
+		self.islandid = None
+		self.yoweb_url = None
+
+		soup = BeautifulSoup(self.yppedia())
+		content = soup.find('div', attrs = {'id': 'content'})
+		yoweb_re = regexp.compile('^http://\w+\.puzzlepirates\.com/'+
+			'yoweb/island/info\.wm\?islandid=(\d+)$')
+		a = soup.find('a', attrs = { 'href': yoweb_re })
+		if a is None:
+			debug('IEI COLLECT YOWEB '+`self.name`+' NONE')
+			return
+
+		debug('IEI COLLECT YOWEB '+`self.name`+' GOT '+``a``)
+		self.yoweb_url = a['href']
+		m = yoweb_re.search(self.yoweb_url)
+		self.islandid = m.group(1)
+
+	def _collect_flagid(self):
+		self.flagid = None
+
+		yo = self.yoweb_url
+		debug('IEI COLLECT FLAGID '+`self.name`+' URL '+`yo`)
+		if yo is None: return None
+		dataf = fetcher.fetch(yo, 1800)
+		soup = BeautifulSoup(dataf)
+		ruler_re = regexp.compile(
+			'/yoweb/flag/info\.wm\?flagid=(\d+)$')
+		ruler = soup.find('a', attrs = { 'href': ruler_re })
+		if not ruler: 
+			debug('IEI COLLECT FLAGID '+`self.name`+' NONE')
+			return
+		debug('IEI COLLECT FLAGID '+`self.name`+' GOT '+``ruler``)
+		m = ruler_re.search(ruler['href'])
+		self.flagid = m.group(1)
+
+	def __str__(self):
+		return `(self.ocean, self.islandid, self.name,
+			self.yoweb_url, self.flagid)`
+
+class IslandFlagInfo(IslandExtendedInfo):
+	# Public data attributes (inherited):
+	#  ocean
+	#  name
+	#  islandid
+	#  yoweb_url
+	#  flagid
+	# Public data attributes (additional):
+	#  flag
+	def __init__(self, ocean, islename):
+		IslandExtendedInfo.__init__(self, ocean, islename)
+		self.flag = None
+		self._collect_flag()
+
+	def _collect_flag(self):
+		if self.flagid is None: return
+		self.flag = FlagInfo(self.flagid, 1800)
+
+	def __str__(self):
+		return IslandExtendedInfo.__str__(self) + '; ' + str(self.flag)
+
+class NullProgressReporter():
+	def start(self): pass
+	def doing(self, msg): pass
+	def stop(self): pass
+
+class TypewriterProgressReporter():
+	def start(self):
+		self._l = 0
+	def doing(self,m):
+		self._doing(m + '...')
+	def _doing(self,m):
+		self._write('\r')
+		self._write(m)
+		less = self._l - len(m)
+		if less > 0:
+			self._write(' ' * less)
+			self._write('\b' * less)
+		self._l = len(m)
+		sys.stdout.flush()
+	def stop(self):
+		self._doing('')
+		self._l = 0
+	def _write(self,t):
+		sys.stdout.write(t)
+
+class OceanInfo():
+	# Public data attributes:
+	#   oi.islands[islename] = IslandInfo(...)
+	#   oi.arches[archname][islename] = IslandInfo(...)
+	def __init__(self, isleclass=IslandBasicInfo, progressreporter=None):
+		if progressreporter is None:
+			if opts.debug: progressreporter = NullProgressReporter()
+			else: progressreporter = TypewriterProgressReporter()
+
+		self.isleclass = isleclass
+		self.ocean = fetcher.ocean.lower().capitalize()
+
+		progressreporter.start()
+		progressreporter.doing('fetching ocean info')
+
+		cmdl = ['./yppedia-ocean-scraper']
+		if opts.localhtml is not None:
+			cmdl += ['--local-html-dir',opts.localhtml]
+		cmdl += [self.ocean]
+		debug('OceanInfo collect running ' + `cmdl`)
+		oscraper = subprocess.Popen(
+			cmdl,
+			stdout = subprocess.PIPE,
+			cwd = yppsc_dir()+'/yarrg',
+			shell=False, stderr=None,
+			)
+		h = oscraper.stdout.readline()
+		debug('OceanInfo collect h '+`h`)
+		assert(regexp.match('^ocean ', h))
+		arch_re = regexp.compile('^ (\S.*)')
+		island_re = regexp.compile('^  (\S.*)')
+
+		oscraper.wait()
+		assert(oscraper.returncode == 0)
+
+		self.islands = { }
+		self.arches = { }
+		archname = None
+
+		isles = [ ]
+		progressreporter.doing('parsing ocean info')
+
+		for l in oscraper.stdout:
+			debug('OceanInfo collect l '+`l`)
+			l = l.rstrip('\n')
+			m = island_re.match(l)
+			if m:
+				assert(archname is not None)
+				islename = m.group(1)
+				isles.append((archname, islename))
+				continue
+			m = arch_re.match(l)
+			if m:
+				archname = m.group(1)
+				assert(archname not in self.arches)
+				self.arches[archname] = { }
+				continue
+			assert(False)
+
+		for i in xrange(0, len(isles)-1):
+			(archname, islename) = isles[i]
+			progressreporter.doing(
+				'fetching isle info %2d/%d (%s: %s)'
+				% (i, len(isles), archname, islename))
+			isle = self.isleclass(self.ocean, islename)
+			isle.arch = archname
+			self.islands[islename] = isle
+			self.arches[archname][islename] = isle
+
+		progressreporter.stop()
+
+	def __str__(self):
+		return `(self.islands, self.arches)`
+
 #---------- pretty-printer for tables of pirate puzzle standings ----------
 
 class StandingsTable:
@@ -681,6 +1014,56 @@ class ChatLogTracker:
 		else:
 			return None
 
+	def local_command(self, metacmd):
+		# returns None if all went well, or problem message
+		return self._command(self._myself.name, metacmd,
+			"local", time.time(), 
+			(lambda m: debug('CMD %s' % metacmd)))
+
+	def _command(self, cmdr, metacmd, chan, timestamp, d):
+		# returns None if all went well, or problem message
+		metacmd = regexp.sub('\\s+', ' ', metacmd).strip()
+		m2 = regexp.match(
+		    '/([adj]) (?:([A-Za-z* ]+)\\s*:)?([A-Za-z ]+)$',
+		    metacmd)
+		if not m2: return "unknown syntax or command"
+
+		(cmd, pattern, targets) = m2.groups()
+		dml = ['cmd', chan, cmd]
+
+		if cmd == 'a': each = self._onboard_event
+		elif cmd == 'd': each = disembark
+		else: each = lambda *l: self._onboard_event(*l,
+				**{'jobber':'applied'})
+
+		if cmdr == self._myself.name:
+			dml.append('self')
+			how = 'cmd: %s' % cmd
+		else:
+			dml.append('other')
+			how = 'cmd: %s %s' % (cmd,cmdr)
+
+		if cmd == 'j':
+			if pattern is not None:
+				return "/j command does not take a vessel"
+			v = None
+		else:
+			v = self._find_matching_vessel(
+				pattern, timestamp, cmdr,
+				dml, create=True)
+
+		if cmd == 'j' or v is not None:
+			targets = targets.strip().split(' ')
+			dml.append(`len(targets)`)
+			for target in targets:
+				each(v, timestamp, target.title(), how)
+			self._vessel_updated(v, timestamp)
+
+		dm = ' '.join(dml)
+		return d(dm)
+
+		return None
+
 	def chatline(self,l):
 		rm = lambda re: regexp.match(re,l)
 		d = lambda m: self._debug_line_disposition(timestamp,l,m)
@@ -783,40 +1166,12 @@ class ChatLogTracker:
 
 		def chat_metacmd(chan):
 			(cmdr, metacmd) = m.groups()
-			metacmd = regexp.sub('\\s+', ' ', metacmd).strip()
-			m2 = regexp.match(
-			    '/([adj]) (?:([A-Za-z* ]+)\\s*:)?([A-Za-z ]+)$',
-			    metacmd)
-			if not m2: return chat(chan)
-
-			(cmd, pattern, targets) = m2.groups()
-			dml = ['cmd', chan, cmd]
-
-			if cmd == 'a': each = self._onboard_event
-			elif cmd == 'd': each = disembark
-			else: each = lambda v,ts,tt,h: self._onboard_event(
-					None,ts,tt,h, jobber='applied')
-
-			if cmdr == self._myself.name:
-				dml.append('self')
-				how = 'cmd: %s' % cmd
+			whynot = self._command(
+				cmdr, metacmd, chan, timestamp, d)
+			if whynot is not None:
+				return chat(chan)
 			else:
-				dml.append('other')
-				how = 'cmd: %s %s' % (cmd,cmdr)
-
-			v = self._find_matching_vessel(
-				pattern, timestamp, cmdr, dml, create=True)
-
-			if v is not None:
-				targets = targets.strip().split(' ')
-				dml.append(`len(targets)`)
-				for target in targets:
-					each(v, timestamp, target.title(), how)
-				self._vessel_updated(v, timestamp)
-
-			dm = ' '.join(dml)
-			chat_core(cmdr, 'cmd '+chan)
-			return d(dm)
+				chat_core(cmdr, 'cmd '+chan)
 
 		m = rm('(\\w+) (?:issued an order|ordered everyone) "')
 		if m: return ob1('general order');
@@ -1014,6 +1369,14 @@ def do_crew_of(args, bu):
 	ci = prep_crew_of(args, bu)
 	print ci
 
+def do_flag_of(args, bu):
+	if len(args) != 1: bu('flag-of takes one pirate name')
+	max_age = 300
+	pi = PirateInfo(args[0], max_age)
+	if pi.flag is None: fi = None
+	else: fi = FlagInfo(pi.flag[0], max_age)
+	print fi
+
 def do_standings_crew_of(args, bu):
 	ci = prep_crew_of(args, bu, 60)
 	tab = StandingsTable(sys.stdout)
@@ -1026,6 +1389,49 @@ def do_standings_crew_of(args, bu):
 			pi = PirateInfo(p, random.randint(900,1800))
 			tab.pirate(pi)
 
+def do_ocean(args, bu):
+	if (len(args)): bu('ocean takes no further arguments')
+	fetcher.default_ocean()
+	oi = OceanInfo(IslandFlagInfo)
+	print oi
+	for islename in sorted(oi.islands.keys()):
+		isle = oi.islands[islename]
+		print isle
+
+def do_embargoes(args, bu):
+	if (len(args)): bu('ocean takes no further arguments')
+	fetcher.default_ocean()
+	oi = OceanInfo(IslandFlagInfo)
+	wr = sys.stdout.write
+	print ('EMBARGOES:  Island    | Owning flag'+
+		'                    | Embargoed flags')
+
+	def getflname(isle):
+		if isle.islandid is None: return 'uncolonisable'
+		if isle.flag is None: return 'uncolonised'
+		return isle.flag.name
+
+	for archname in sorted(oi.arches.keys()):
+		print 'ARCHIPELAGO: ',archname
+		for islename in sorted(oi.arches[archname].keys()):
+			isle = oi.islands[islename]
+			wr(' %-20s | ' % isle.name)
+			flname = getflname(isle)
+			wr('%-30s | ' % flname)
+			flag = isle.flag
+			if flag is None: print ''; continue
+			delim = ''
+			for rel in flag.relations:
+				(oname, oid, dummy, thisdeclaring,
+					odeclaringmin,odeclaringmax) = rel
+				if thisdeclaring >= 0: continue
+				wr(delim)
+				wr(oname)
+				delim = '; '
+			print ''
+
+#----- modes which use the chat log parser are quite complex -----
+
 class ProgressPrintPercentage:
 	def __init__(self, f=sys.stdout):
 		self._f = f
@@ -1041,8 +1447,6 @@ class ProgressPrintPercentage:
 		self._f.write('                   \r')
 		self._f.flush()
 
-#----- modes which use the chat log parser are quite complex -----
-
 def prep_chat_log(args, bu,
 		progress=ProgressPrintPercentage(),
 		max_myself_age=3600):
@@ -1214,15 +1618,27 @@ def ship_aid_core(myself, track, displayer, kreader):
 	rotate_nya = '/-\\'
 
 	sort = NameSorter()
+	clicmd = None
+	clierr = None
+	cliexec = None
 
 	while True:
 		track.catchup()
 		now = time.time()
 
-		(vn, s) = find_vessel()
-		s = track.myname() + s
-		s += " at %s" % time.strftime("%Y-%m-%d %H:%M:%S")
-		s += kreader.info()
+		(vn, vs) = find_vessel()
+
+		s = ''
+		if cliexec is not None:
+			s += '...'
+		elif clierr is not None:
+			s += 'Error: '+clierr
+		elif clicmd is not None:
+			s += '/' + clicmd
+		else:
+			s = track.myname() + vs
+			s += " at %s" % time.strftime("%Y-%m-%d %H:%M:%S")
+			s += kreader.info()
 		s += '\n'
 
 		tbl_s = StringIO()
@@ -1263,11 +1679,34 @@ def ship_aid_core(myself, track, displayer, kreader):
 		displayer.show(s)
 		tbl_s.close()
 
+		if cliexec is not None:
+			clierr = track.local_command("/"+cliexec.strip())
+			cliexec = None
+			continue
+
 		k = kreader.getch()
 		if k is None:
 			rotate_nya = rotate_nya[1:3] + rotate_nya[0]
 			continue
 
+		if clierr is not None:
+			clierr = None
+			continue
+
+		if clicmd is not None:
+			if k == '\r' or k == '\n':
+				cliexec = clicmd
+				clicmd = clicmdbase
+			elif k == '\e' and clicmd != "":
+				clicmd = clicmdbase
+			elif k == '\33':
+				clicmd = None
+			elif k == '\b' or k == '\177':
+				clicmd = clicmd[ 0 : len(clicmd)-1 ]
+			else:
+				clicmd += k
+			continue
+
 		if k == 'q': break
 		elif k == 'g': sort = SkillSorter('Gunning')
 		elif k == 'c': sort = SkillSorter('Carpentry')
@@ -1277,6 +1716,8 @@ def ship_aid_core(myself, track, displayer, kreader):
 		elif k == 'd': sort = SkillSorter('Battle Navigation')
 		elif k == 't': sort = SkillSorter('Treasure Haul')
 		elif k == 'a': sort = NameSorter()
+		elif k == '/': clicmdbase = ""; clicmd = clicmdbase
+		elif k == '+': clicmdbase = "a "; clicmd = clicmdbase
 		else: pass # unknown key command
 
 #---------- individual keystroke input ----------
@@ -1310,7 +1751,7 @@ class KeystrokeReader(DummyKeystrokeReader):
 #---------- main program ----------
 
 def main():
-	global opts, fetcher
+	global opts, fetcher, yppedia
 
 	pa = OptionParser(
 '''usage: .../yoweb-scrape [OPTION...] ACTION [ARGS...]
@@ -1339,6 +1780,9 @@ display modes (for --display) apply to ship-aid:
 	ao('--display', action='store', dest='display',
 		type='choice', choices=['dumb','overwrite'],
 		help='how to display ship aid')
+	ao('--local-ypp-dir', action='store', dest='localhtml',
+		help='get yppedia pages from local directory LOCALHTML'+
+			' instead of via HTTP')
 
 	ao_jt = lambda wh, t: ao(
 		'--timeout-sa-'+wh, action='store', dest='timeout_'+wh,
@@ -1389,7 +1833,8 @@ display modes (for --display) apply to ship-aid:
 		else:
 			opts.display = 'overwrite'
 
-	fetcher = Fetcher(opts.ocean, opts.cache_dir)
+	fetcher = Yoweb(opts.ocean, opts.cache_dir)
+	yppedia = Yppedia(opts.cache_dir)
 
 	mode_fn(args[1:], pa.error)