001:
002:
003:
004:
005:
006:
007:
008:
009: reloadables=[]
010:
011:
012:
013: import sys,re
014: import bisect
015: from utility.verbose import vv,vvv,vvvv
016: from relational import base
017: from standing import boatbase,boatconf,confbase,enumstat,eventstat
018:
019:
020:
021: class ScrapeConfigurationEntry(confbase.ConfValueEntry):
022: def __init__(self,race,boid,division=None,fleet=None,rating=None):
023: assert isinstance(race,eventstat.RaceName)
024: self.race=race
025: assert isinstance(boid,boatconf.BoatIdentificationEntry)
026: self.boid=boid
027: if division: self.division=division
028: if fleet: self.fleet=fleet
029: if rating: self.rating=rating
030:
031:
032: self.entuple=(boid,division,fleet,rating)
033:
034: def scraping_details(self):
035: try:
036: if self.division in eventstat.PHRFNAMES:
037: self.certname="Scraped Base"
038: self.authority="Scraped"
039: self.jog=False
040: self.onedesign=False
041: self.kind=0
042: elif self.division in eventstat.JOGNAMES:
043: self.certname="Scraped JOG"
044: self.authority="Scraped"
045: self.jog=True
046: self.onedesign=False
047: self.kind=1
048: elif self.division in eventstat.ONEDESIGNNAMES:
049: self.certname="Scraped One-design"
050: self.authority="Scraped"
051: self.jog=False
052: self.onedesign=True
053: self.kind=2
054: except AttributeError:
055: pass
056: try:
057: self.fleet.inseries
058: except AttributeError:
059: self.series=True
060: self.deltarating=0
061: else:
062: self.series=False
063:
064: def regi(self,cert,flco):
065: return self.create_cert_flco_regi(cert,flco)[2]
066:
067: def flco_regi(self,cert):
068: return self.create_cert_flco_regi(cert)[1:]
069:
070: def cert_flco_regi(self):
071: return self.create_cert_flco_regi()
072:
073: def create_cert_flco_regi(self,cert=None,flco=None):
074: self.scraping_details()
075: if cert==None:
076: cert=boatconf.CertificationEntry(
077: self.boid,
078: getattr(self,"certname","Scraped"),
079: authority=getattr(self,"authority","Scraped"),
080: jog=getattr(self,"jog",False),
081: onedesign=getattr(self,"onedesign",False),
082: rating=getattr(self,"rating",0),
083: )
084: else:
085: if cert.kind<>self.kind: raise ValueError
086: if flco==None:
087: flco=boatconf.FleetConfigurationEntry(
088: cert,
089: self.division,
090: getattr(self,"coname",str(self.fleet)),
091: fleet=self.fleet,
092: deltarating=getattr(self,"deltarating",0),
093: )
094: regi=boatconf.RegistrationEntry(
095: flco,
096: "Implicit from %s"%self.race.abbrev,
097: implicitfrom=self.race,
098: )
099: return (cert,flco,regi)
100:
101: def nonzero(*x):
102: if x and x[-1]:
103: return x[-1]
104: else:
105: raise AttributeError
106:
107: class ScrapeBase(boatbase.BoatConfBase):
108:
109: def __init__(self):
110: boatbase.BoatConfBase.__init__(self)
111: self.cobyboco=confbase.ConfDict()
112:
113:
114:
115:
116: def get_racename(self,s,r):
117: return eventstat.get_racename(s,r)
118:
119: def new_scraping(
120: self,race,
121: sailnumber="",boatname="",division=None,fleet=None,rating=None,
122: ):
123:
124:
125: bo=self.new_boat_identification(None,sailnumber,boatname)
126: co=ScrapeConfigurationEntry(race,bo,division,fleet,rating)
127: if (bo,co) not in self.cobyboco or co.race>self.cobyboco[bo,co].race:
128: self.cobyboco[bo,co]=co
129:
130: from standing.loadfile import import_all_timesheets
131:
132: def import_timesheet(
133: self,racename,racesheetf,startsheetf,timesheetf,ubersheetf
134: ):
135: if isinstance(racesheetf,file):
136: try:
137: try:
138: noglobals={"__builtins__":None}
139: l=racesheetf.readline()
140: [bs,bn,ab,ds,ps]=eval(l,noglobals)
141: if bs:
142: self.new_scraping(
143: racename,
144: sailnumber=bs,
145: boatname=bn,
146: )
147: finally:
148: racesheetf.close()
149: except (EOFError,SyntaxError): pass
150:
151: if isinstance(startsheetf,file):
152: startsheetf.close()
153:
154: if isinstance(timesheetf,file):
155: try:
156: try:
157: noglobals={"__builtins__":None}
158: for l in timesheetf:
159: [en,bs,bn,fc,ft,cd,cf,cr,ps]=eval(l,noglobals)
160: try: dv=eventstat.DivisionName(cd,strict=True)
161: except ValueError: dv=None
162: try: fl=enumstat.FleetEnum(cf,strict=True)
163: except ValueError: fl=None
164: try: rt=int(cr)
165: except ValueError:
166: try: rt=dv.levelrating
167: except AttributeError: rt=None
168: self.new_scraping(
169: racename,
170: sailnumber=bs or None,
171: boatname=bn or None,
172: division=dv,
173: fleet=fl,
174: rating=rt,
175: )
176: finally:
177: timesheetf.close()
178: except (EOFError,SyntaxError): pass
179:
180: if isinstance(ubersheetf,file):
181: try:
182: try:
183: noglobals={"__builtins__":None}
184: for l in ubersheetf:
185: [en,bs,bn,cd,cf,sf,ss,sc,sw,ps]=eval(l,noglobals)
186: try: dv=eventstat.DivisionName(cd,strict=True)
187: except ValueError: dv=None
188: try: fl=enumstat.FleetEnum(cf,strict=True)
189: except ValueError: fl=None
190: self.new_scraping(
191: racename,
192: sailnumber=bs or None,
193: boatname=bn or None,
194: division=dv,
195: fleet=fl,
196: )
197: finally:
198: ubersheetf.close()
199: except (EOFError,SyntaxError): pass
200:
201: def process_scrapings(self):
202: for co in self.cobyboco.values():
203: co.scraping_details()
204:
205: def scraping_hierarchy(self):
206: print>>vvv,"COLLATING BOAT CONFIGURATION DATA"
207: newbase=boatbase.BoatConfBase()
208: for (
209: boid,[[boidlistindex],bzcs,bcs,bzfs,bfs,brs,bcos]
210: ) in base.polyhierarchy_filter(
211: ["boid"],
212: self.boidlist.semistable_sort(),
213: base.adjoin_sort(
214: self.certlist.converse_filter(
215: [("rating",nonzero)]
216: ),
217: ["boid"]
218: ),
219: base.adjoin_sort(
220: self.certlist.adjoin_filter(
221: [("rating",nonzero)]
222: ),
223: ["boid"]
224: ),
225: base.adjoin_sort(
226: base.converse_filter(
227: self.flcolist.adjoin_filter(
228: ["division","fleet"]
229: ),
230: [("cert",lambda f,c: nonzero(f,c.rating))]
231: ),
232: [("cert",lambda f,c: c.boid)]
233: ),
234: base.adjoin_sort(
235: base.adjoin_filter(
236: base.adjoin_filter(
237: self.flcolist.semistable_filter(),
238: ["division","fleet"]
239: ),
240: [("deltarating",lambda f,d: f.cert.rating+d)]
241: ),
242: [("cert",lambda f,c: c.boid)]
243: ),
244: base.adjoin_sort(
245: base.adjoin_filter(
246: base.adjoin_filter(
247: self.regilist.adjoin_filter(["flco"]),
248: [
249: ("flco",lambda r,f: f.division),
250: ("flco",lambda r,f: f.fleet),
251: ]
252: ),
253: [("flco",lambda r,f: f.cert.rating+f.deltarating)]
254: ),
255: [("flco",lambda r,f: f.cert.boid)]
256: ),
257: base.adjoin_sort(
258: base.adjoin_filter(
259: self.cobyboco.values().adjoin_filter(
260: ["division","fleet"]
261: ),
262: ["rating"]
263: ),
264: ["boid"]
265: ),
266: ):
267: print>>vv," BOID:",boid
268: newbase.boidlist.append(boid)
269: zerocerts=list(bzcs)
270: zeroflcos=list(bzfs)
271: for (
272: rating,[certs,rfs,rrs,rcos]
273: ) in base.polyhierarchy_filter(
274: ["rating"],bcs,bfs,brs,bcos
275: ):
276: newcerts=[]
277: newflcos=[]
278: newregis=[]
279: print>>vvv," RATING:",rating
280: for cert in certs:
281: print>>vvv," CERT:",cert.certname
282: newcerts.append(cert)
283: if rating:
284: for cert in certs:
285: print>>vvv," CERT:",cert.certname
286: newcerts.append(cert)
287: for (division,fleets) in base.polyhierarchy_filter(
288: ["division","fleet"],zeroflcos,rfs,rrs,rcos
289: ):
290: for (fleet,[fzfs,ffs,frs,fcos]) in fleets:
291: print>>vvv," DIVISION:FLEET: %s:%s"%(
292: division,fleet
293: )
294: try:
295: [co]=list(fcos)
296: except ValueError:
297: co=None
298: someflcos=False
299: for (
300: flco,[[flcoi],regis]
301: ) in base.polyhierarchy_filter(
302: ["flco"],ffs,frs
303: ):
304: someflcos=True
305: newflcos.append(flco)
306: if co<>None:
307: newregis.extend(regis)
308: if co<>None:
309: try:
310: [zflco]=list(fzfs)
311: except ValueError:
312: zflco=None
313: else:
314: try:
315: zflco.deltarating
316: except AttributeError:
317: ncert=zflco.cert.clone(
318: rating=rating
319: )
320: newcerts.append(ncert)
321: nflco=zflco.clone(
322: cert=ncert,
323: deltarating=0,
324: )
325: newflcos.append(nflco)
326: nregi=co.regi(ncert,nflco)
327: newregis.append(nregi)
328: else:
329: if zflco.deltarating==0:
330: ncert=zflco.cert.clone(
331: rating=rating
332: )
333: newcerts.append(ncert)
334: print>>vv," RESET "\
335: "FROM ZERO:",ncert.certname
336: nflco=zflco.clone(
337: cert=ncert,
338: )
339: newflcos.append(nflco)
340: nregi=co.regi(ncert,nflco)
341: newregis.append(nregi)
342: else:
343: zflco=None
344: if zflco==None and not someflcos:
345: for cert in newcerts:
346: try:
347: (nflco,nregi)=co.flco_regi(cert)
348: except ValueError:
349: pass
350: else:
351: newflcos.append(nflco)
352: newregis.append(nregi)
353: break
354: else:
355: (ncert,nflco,nregi)=\
356: co.cert_flco_regi()
357: newcerts.append(ncert)
358: newflcos.append(nflco)
359: newregis.append(nregi)
360: newcerts.sort()
361: newflcos.sort()
362: newregis.sort()
363: newbase.certlist.extend(newcerts)
364: newbase.flcolist.extend(newflcos)
365: newbase.regilist.extend(newregis)
366: return newbase
367:
368: