Download platform/modules/map.py from fsanyoto/loopable: direct link, hf CLI and curl.
- Browser
- Download file 15.3 kB
-
https://huggingface.co/spaces/fsanyoto/loopable/resolve/main/platform/modules/map.py
- Command line
-
hf download hf://spaces/fsanyoto/loopable/platform/modules/map.py
-
curl -L -o map.py https://huggingface.co/spaces/fsanyoto/loopable/resolve/main/platform/modules/map.py
15.3 kB
| """Map module β every customer pinned at their EXACT street address (not city-aggregated). | |
| Coordinates resolve in this order, per customer: | |
| 1. Odoo's own partner_latitude / partner_longitude when present; | |
| 2. else a geocode of the street address, cached in the writable HF store (`geocoords.json`, | |
| keyed by partner id + an address hash so a changed address re-geocodes). Geocoding uses the | |
| free US Census batch geocoder (these customers are almost all US/NY-metro florists). | |
| Customers with no usable address (or a geocode that fails) fall to a list under the map. | |
| This pipeline serves Odoo `res.partner` rows only, and its US Census lookup is US only. The general | |
| on-demand geocoder for every other database is `aios-web/api/routes_geo.py`. | |
| Odoo stays STRICTLY read-only β geocodes are cached in the platform's own store, never written back | |
| to Odoo. The map's purpose is select-and-export (e.g. to assign agents): box/lasso-select on the map | |
| builds an Excel list. Assigning agents happens in Odoo / via that export, never as an app write. | |
| """ | |
| import csv | |
| import io | |
| import hashlib | |
| from harness.canonical_source import odoo as O | |
| import core.periods as P | |
| import core.store as store | |
| import modules.sales as sales_mod | |
| import modules.customers as cust_mod | |
| _GEO_NS = 'geocoords' # store file: {str(pid): {lat,lon,src,h,addr}} | |
| _BASE_FROM = '2015-01-01' # "all-time" floor for the customer base | |
| _CENSUS_URL = 'https://geocoding.geo.census.gov/geocoder/locations/addressbatch' | |
| # Americas bounds (US + AK/HI + PR/VI + Canada + Caribbean/Guyana) β wide enough for every real | |
| # customer, tight enough to still reject garbage coordinates (0,0 / Europe / Asia). | |
| _LAT_LO, _LAT_HI, _LON_LO, _LON_HI = 6.0, 60.0, -160.0, -58.0 | |
| def _today_iso(): | |
| return P.today().isoformat() | |
| def _norm_state(s): | |
| return (s or '').replace(' (US)', '').strip() | |
| def _addr_parts(p): | |
| """(street, city, state, zip) cleaned from a res.partner row.""" | |
| street = ' '.join(x for x in [(p.get('street') or '').strip(), | |
| (p.get('street2') or '').strip()] if x) | |
| return (street, (p.get('city') or '').strip(), | |
| _norm_state(O.m2o_name(p.get('state_id'))), (p.get('zip') or '').strip()) | |
| def _addr_str(p): | |
| return ', '.join(x for x in _addr_parts(p) if x) | |
| def _addr_hash(p): | |
| return hashlib.sha1('|'.join(_addr_parts(p)).lower().encode('utf-8')).hexdigest()[:16] | |
| def _has_coords(p): | |
| la, lo = p.get('partner_latitude'), p.get('partner_longitude') | |
| return bool(la) and bool(lo) and (abs(la) > 1e-6 or abs(lo) > 1e-6) | |
| def _in_bounds(lat, lon): | |
| return lat is not None and lon is not None and _LAT_LO <= lat <= _LAT_HI and _LON_LO <= lon <= _LON_HI | |
| def _base_pids(team_id=None, agent_pids=None): | |
| """Partner ids of every customer with a confirmed order in scope (team/agent), giftware | |
| excluded β via the same order_domain the rest of the app uses.""" | |
| g = O.read_group('sale.order', | |
| sales_mod.order_domain(_BASE_FROM, _today_iso(), team_id, partner_ids=agent_pids), | |
| ['amount_untaxed:sum'], ['partner_id'], lazy=False) | |
| return [O.m2o_id(r.get('partner_id')) for r in g if O.m2o_id(r.get('partner_id'))] | |
| def _read_partners(pids): | |
| """One res.partner read: address + Odoo coords + agent, with agent ids resolved to names.""" | |
| if not pids: | |
| return [], {} | |
| # ('active','in',[True,False]) keeps archived partners that still carry orders, so the map | |
| # covers every order customer and reconciles to the distinct-partner count. | |
| parts = O.search_read('res.partner', [('id', 'in', list(pids)), ('active', 'in', [True, False])], | |
| ['name', 'street', 'street2', 'city', 'state_id', 'zip', 'country_id', | |
| 'partner_latitude', 'partner_longitude', 'agent_ids']) | |
| aids = {a for p in parts for a in (p.get('agent_ids') or [])} | |
| anames = ({x['id']: x['name'] for x in | |
| O.search_read('res.partner', [('id', 'in', list(aids))], ['name'])} if aids else {}) | |
| return parts, anames | |
| def customer_locations(t=None, team_id=None, agent_pids=None, *, st=None, user=None): | |
| """The map dataset. Returns {'located', 'unlocated', 'stats', 'validation'}. | |
| Each located row: pid, customer, lat, lon, source, address, city, state, zip, agent, | |
| rev_ltm, rev_total, orders, last_order. Unlocated rows carry a 'reason' instead of lat/lon.""" | |
| t = t or P.today() | |
| lf, lt = P.ltm(t) | |
| today = _today_iso() | |
| dom = sales_mod.order_domain(_BASE_FROM, today, team_id, partner_ids=agent_pids) | |
| # Wave 1 β five independent reads concurrently (this is the slow part): all-time revenue (which | |
| # also yields the customer set), LTM revenue, last-order dates, the independent base count, and | |
| # the geocode cache. Running them in parallel cuts a cold load from ~15s to ~5s. | |
| all_rev, ltm_rev, last_ord, base_indep, cache = O.parallel([ | |
| lambda: cust_mod._cust_rev(_BASE_FROM, today, team_id, agent_pids), | |
| lambda: cust_mod._cust_rev(lf, lt, team_id, agent_pids), | |
| lambda: cust_mod._last_order_dates(_BASE_FROM, today, team_id, agent_pids), | |
| lambda: O.distinct_count('sale.order', dom, 'partner_id'), | |
| lambda: (store.get(_GEO_NS) if store.available() else {}), | |
| ]) | |
| # Agent-scoped map = the agent's WHOLE assigned book (a "my customers" coverage view), NOT just | |
| # the order-history subset. Active accounts with an address that simply haven't ordered yet are | |
| # still the agent's customers and belong on their map β so the count reconciles to the Agents-page | |
| # book (e.g. an agent's 114 assigned customers show 114, not the 80 who happen to have ordered). | |
| # A never-ordered customer has no BU, so this only applies in the All-BU view; a specific-BU map | |
| # stays order-based, since BU is derived from orders (owner 2026-07-21). | |
| book_scoped = agent_pids is not None and team_id is None | |
| pids = list(set(all_rev.keys()) | (set(agent_pids) if book_scoped else set())) | |
| if not pids: | |
| return {'located': [], 'unlocated': [], | |
| 'stats': {'total': 0, 'located': 0, 'unlocated': 0, 'no_agent': 0, 'need_geocode': 0}, | |
| 'validation': validate_rows(0, 0, 0, base_indep)} | |
| parts, anames = _read_partners(pids) # Wave 2 β needs the customer ids from Wave 1 | |
| located, unlocated = [], [] | |
| for p in parts: | |
| pid = p['id'] | |
| ag = p.get('agent_ids') or [] | |
| row = { | |
| 'pid': pid, 'customer': p.get('name') or f'#{pid}', | |
| 'address': _addr_str(p), | |
| 'city': ((p.get('city') or '').strip().title()) or '(none)', | |
| 'state': _norm_state(O.m2o_name(p.get('state_id'))) or '(none)', | |
| 'zip': (p.get('zip') or '').strip(), | |
| 'agent': (anames.get(ag[0]) or '(none)') if ag else '(none)', | |
| 'rev_ltm': (ltm_rev.get(pid) or {}).get('rev', 0.0), | |
| 'rev_total': (all_rev.get(pid) or {}).get('rev', 0.0), | |
| 'orders': (all_rev.get(pid) or {}).get('orders', 0), | |
| 'last_order': last_ord.get(pid, ''), | |
| } | |
| lat = lon = src = None | |
| if _has_coords(p): | |
| lat, lon, src = p['partner_latitude'], p['partner_longitude'], 'odoo' | |
| else: | |
| c = cache.get(str(pid)) | |
| if c and c.get('h') == _addr_hash(p) and c.get('lat') is not None: | |
| lat, lon, src = c['lat'], c['lon'], c.get('src', 'geocode') | |
| if _in_bounds(lat, lon): | |
| located.append({**row, 'lat': round(lat, 6), 'lon': round(lon, 6), 'source': src}) | |
| else: | |
| _street, _city, _stt, _zip = _addr_parts(p) | |
| geocodable = bool(_street and (_city or _zip)) | |
| if not row['address']: | |
| reason = 'no address in Odoo' | |
| elif (cache.get(str(pid)) or {}).get('src') == 'census_nomatch': | |
| reason = 'address could not be located' | |
| elif geocodable: | |
| reason = 'not geocoded yet' | |
| else: | |
| reason = 'address too incomplete to locate' | |
| unlocated.append({**row, 'reason': reason}) | |
| located.sort(key=lambda r: -r['rev_ltm']) | |
| unlocated.sort(key=lambda r: -r['rev_ltm']) | |
| stats = { | |
| 'total': len(parts), 'located': len(located), 'unlocated': len(unlocated), | |
| 'no_agent': sum(1 for r in (located + unlocated) if r['agent'] == '(none)'), | |
| 'need_geocode': sum(1 for r in unlocated if r['reason'] == 'not geocoded yet'), | |
| } | |
| # Reconcile to the set we set out to map: the agent's full book when book-scoped, else the | |
| # independent distinct-order-customer count. | |
| recon = len(pids) if book_scoped else base_indep | |
| result = {'located': located, 'unlocated': unlocated, 'stats': stats, | |
| 'validation': validate_rows(len(parts), len(located), len(unlocated), recon, | |
| bad=[r for r in located if not _in_bounds(r['lat'], r['lon'])])} | |
| if st is not None or user is not None: | |
| from core import personal_reads | |
| personal_reads.record_rows('customer_data', [ | |
| {'customer': row['customer'], 'street': row['address'], 'city': row['city'], | |
| 'state': row['state'], 'zip': row['zip']} for row in located + unlocated], | |
| st=st, user=user) | |
| return result | |
| def coords_for(pids, *, st=None): | |
| """{pid: {'lat','lon'}} for the given partners β Odoo's own coordinates, else the geocode | |
| CACHE (read-only reuse; NEVER triggers geocoding). Wave-7 W11: the Customer table's Map | |
| VIEW reads these off the pool rows; the standalone Map page retired the same day, and | |
| this module survives as the geocode library.""" | |
| if not pids: | |
| return {} | |
| try: | |
| if st is None: | |
| cache = store.get(_GEO_NS) if store.available() else {} | |
| else: | |
| cache = st.selected_values(_GEO_NS, [], pids) | |
| parts = O.search_read( | |
| 'res.partner', [('id', 'in', list(pids)), ('active', 'in', [True, False])], | |
| ['street', 'street2', 'city', 'state_id', 'zip', | |
| 'partner_latitude', 'partner_longitude']) | |
| except Exception: | |
| return {} # a table that renders without pins beats a table that cannot render | |
| out = {} | |
| for p in parts: | |
| lat = lon = None | |
| if _has_coords(p): | |
| lat, lon = p['partner_latitude'], p['partner_longitude'] | |
| else: | |
| c = cache.get(str(p['id'])) | |
| if c and c.get('h') == _addr_hash(p) and c.get('lat') is not None: | |
| lat, lon = c['lat'], c['lon'] | |
| if _in_bounds(lat, lon): | |
| out[p['id']] = {'lat': round(lat, 6), 'lon': round(lon, 6)} | |
| return out | |
| def validate_rows(total, n_loc, n_unloc, base_indep, bad=None): | |
| """Reconcile the map dataset to an independent Odoo aggregate (distinct order partners).""" | |
| checks = [{ | |
| 'check': 'Map: located + unlocated == customers in scope', | |
| 'a': n_loc + n_unloc, 'b': base_indep, 'gap': (n_loc + n_unloc) - base_indep, | |
| 'ok': (n_loc + n_unloc) == base_indep, | |
| }, { | |
| 'check': 'Map: every plotted point within plausible bounds', | |
| 'a': n_loc - len(bad or []), 'b': n_loc, 'gap': -len(bad or []), 'ok': not (bad or []), | |
| }] | |
| return checks | |
| def validate(team_id=None): | |
| """Registry hook for validate.py.""" | |
| return customer_locations(team_id=team_id)['validation'] | |
| # ---------------------------------------------------------------- geocoding (US Census batch) | |
| def _geocodable_pids(team_id=None): | |
| """Every customer that can appear on a map: order-customers (per the team filter) PLUS every | |
| customer ASSIGNED to an agent. The latter is why an agent's never-ordered accounts can be | |
| geocoded and pinned on their 'my customers' map (customer_locations now includes the full book); | |
| without it those addresses would never enter the geocode queue.""" | |
| pids = set(_base_pids(team_id)) | |
| for p in O.search_read('res.partner', [('agent_ids', '!=', False), ('active', 'in', [True, False])], | |
| ['id'], limit=100000): | |
| pids.add(p['id']) | |
| return list(pids) | |
| def _pending_geocode(team_id=None): | |
| """res.partner rows with an address, no Odoo coords, and no cache entry for that exact address.""" | |
| pids = _geocodable_pids(team_id) | |
| parts, _ = _read_partners(pids) | |
| cache = store.get(_GEO_NS) if store.available() else {} | |
| pend = [] | |
| for p in parts: | |
| if _has_coords(p): | |
| continue | |
| street, city, _state, zc = _addr_parts(p) | |
| if not (street and (city or zc)): | |
| continue # too little to geocode β stays unlocated | |
| c = cache.get(str(p['id'])) | |
| if c and c.get('h') == _addr_hash(p): | |
| continue # already attempted for this exact address | |
| pend.append(p) | |
| return pend, cache | |
| def geocode_missing(team_id=None, limit=None, _chunk=2000): | |
| """Geocode pending addresses via the US Census batch geocoder; cache results (incl. no-match, | |
| so we never retry the same address) in the HF store. Returns a summary dict. Read-only on Odoo.""" | |
| if not store.available(): | |
| return {'error': 'No writable store (HF_TOKEN missing).'} | |
| try: | |
| import requests | |
| except ImportError: | |
| return {'error': 'requests not installed'} | |
| pend, cache = _pending_geocode(team_id) | |
| if limit: | |
| pend = pend[:limit] | |
| if not pend: | |
| return {'attempted': 0, 'matched': 0, 'failed': 0, 'cache_size': len(cache)} | |
| matched = failed = 0 | |
| for i in range(0, len(pend), _chunk): | |
| batch = pend[i:i + _chunk] | |
| buf = io.StringIO() | |
| w = csv.writer(buf) | |
| for p in batch: | |
| street, city, state, zc = _addr_parts(p) | |
| w.writerow([p['id'], street, city, state, zc]) | |
| try: | |
| resp = requests.post(_CENSUS_URL, | |
| files={'addressFile': ('a.csv', buf.getvalue(), 'text/csv')}, | |
| data={'benchmark': 'Public_AR_Current'}, timeout=300) | |
| resp.raise_for_status() | |
| except Exception as e: | |
| store.put(_GEO_NS, cache) | |
| return {'error': f'Census request failed: {e}', 'matched': matched, 'failed': failed} | |
| by_pid = {p['id']: p for p in batch} | |
| for row in csv.reader(io.StringIO(resp.text)): | |
| if not row: | |
| continue | |
| try: | |
| pid = int(row[0]) | |
| except (ValueError, IndexError): | |
| continue | |
| p = by_pid.get(pid) | |
| if p is None: | |
| continue | |
| h = _addr_hash(p) | |
| if len(row) >= 6 and row[2] == 'Match' and row[5]: | |
| lon, lat = row[5].split(',') | |
| cache[str(pid)] = {'lat': float(lat), 'lon': float(lon), 'src': 'census', | |
| 'h': h, 'addr': row[4]} | |
| matched += 1 | |
| else: | |
| cache[str(pid)] = {'lat': None, 'lon': None, 'src': 'census_nomatch', 'h': h} | |
| failed += 1 | |
| store.put(_GEO_NS, cache) | |
| return {'attempted': len(pend), 'matched': matched, 'failed': failed, 'cache_size': len(cache)} | |