Een dienstenpakket vergelijken met ChatGPT 5.6 Luna
·
45 min lezen
Hieronder vind je een vergelijking gemaakt door ChatGPT 5.6 Luna van 2 dienstenpakketten.
In plaats van alleen het eindoordeel te tonen, staat hieronder de volledige ruwe terminaloutput. Daardoor is zichtbaar hoe de analyse van de oorspronkelijke vraag naar het uiteindelijke overzicht is opgebouwd: het uitlezen van de PDF’s, het inventariseren van dienstnummers, het normaliseren van voertuigbenamingen, het controleren van materieeltoewijzingen en het vergelijken van de onderliggende 4900-diensten.
De output is bewust niet opgeschoond. Ook de interne analyse, tussenresultaten, foutmeldingen en correcties zijn behouden. Op brede schermen gebruikt het terminalvenster de volledige beschikbare breedte; op smalle apparaten blijft horizontaal scrollen mogelijk zodat de terminalregels intact blijven.
Volledige ruwe analyse
╭─── omp v17.4.0 ──────────────────────────────────────────────────────────────────────────────────╮
│ │ Tips │
│ Welcome back! │ # for prompt actions │
│ │ / for commands │
│ ▀██████████▀ │ ! to run bash │
│ ╘██ ██ │ $ to run python │
│ ██ ██ │ ───────────────────────────────────────────────────────────────────── │
│ ██ ██ │ LSP Servers │
│ ▄██▄ ▄██▄ │ No LSP servers │
│ │ │
│ GPT-5.6 Luna │ │
│ opencode-go │ │
│ │ ───────────────────────────────────────────────────────────────────── │
│ │ Recent sessions │
│ │ • Vergelijk dienstenpakketten oud en nieuw (just now) │
│ │ │
│ │ │
│ │ │
│ │ │
╰──────────────────────────┴───────────────────────────────────────────────────────────────────────╯
Tip: Press shift+tab to cycle through reasoning effort levels
@nieuw.pdf en @oud.pdf zijn twee dienstenpakketten die heel erg veel op elkaar lijken. behalve de ingangsdatum die uiteraard verschilt, waarin verschillen de diensten inhoudelijk van
elkaar. kun je een overzicht geven, en zijn er dienstnummers die helemaal weg zijn of juist nieuw erbij zijn gekomen?
└─ Read nieuw.pdf (skipped: binary, 476.7KB)
└─ Read oud.pdf (skipped: binary, 455.6KB)
Considering PDF comparison
I need to compare PDFs by reading them as binary to extract text, and I should do this in Dutch. It seems like I might need to inspect the files, and possibly use a tool like pdftotext in
bash for this process. I think reading both PDFs in parallel might be the best approach. I'm curious how well this will work, but it feels like a solid plan to get the text I need!
• Read (2)
├─ nieuw.pdf
└─ oud.pdf
Extracting PDF data
I'm planning to use Python with the pypdf library to extract data. First, I need to verify that the package is correct. Then I'll look into parsing specific service headings like V/L 4001.
I want to semantically compare content, focusing on services ranging from 4001 to maybe 4040, though older data might go up to 4042. I'll need lists for precision and consider using
pdftotext in a bash pipeline. Using eval with Python seems like the way to go for efficiency!
╭─── 🐍 • Controleer pdf-lezer · (192ms) ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ from pathlib import Path │
│ import re │
│ try: │
│ import pypdf │
│ print('pypdf', pypdf.__version__) │
│ except Exception as e: │
│ print(type(e).__name__, e) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ ModuleNotFoundError No module named 'pypdf' │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Exploring PDF text extraction methods
I’m considering using PyPDF2 or possibly pdftotext through subprocess in eval—wondering if that’s allowed. I might look into using pathlib and subprocess as alternatives. I’ll also check if
pdftotext is available using a bash command. There are quite a few details here, and I want to ensure I choose the best method to extract text from PDFs effectively. Let’s see how this all
ties together!
╭─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ $ which pdftotext │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ /opt/homebrew/bin/pdftotext │
│ ⟦Wall: 0.01s | Timeout: 300s⟧ │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─── 🐍 • Extraheer PDF-tekst · (493ms) ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ import subprocess, re, json, textwrap │
│ from pathlib import Path │
│ texts={} │
│ for fn in ['oud.pdf','nieuw.pdf']: │
│ texts[fn]=subprocess.run(['pdftotext','-layout',fn,'-'],capture_output=True,text=True,check=True).stdout │
│ print(fn, len(texts[fn]), texts[fn].count('\f'), 'pages') │
│ print(texts['oud.pdf'][:500]) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ │
│ │
│ Ingangsdatum : 15/03/2026 04:34 - 12:25 7h51 │
│ Lijn Omloop Ritnr Vertrek Van Naar Aankomst │
│ Meenemen Elektrisch 12,2m M-net │
│ 04:34 Opstaptijd 04:40 │
│ 04:40 Stekkeren 04:41 │
│ MAT 1701 04:41 Zdm Gar Mar Min 05:14 │
│ 111 1000 05:14 Mar │
│ … 7 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Parsing PDF text
I'm noticing an interesting read that involves extracting data from a PDF of 208 pages. It seems there are new lines, perhaps including all service cards and notes. I need to parse the
document properly. I think I'll start by listing service headings with a regex pattern like Dienst:\s+[VL]\s+(\d+) to capture all relevant information. That feels like a good plan to get
the details I need!
╭─── 🐍 • Inventariseer dienstnummers · (2ms) ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for fn,t in texts.items(): │
│ svcs=re.findall(r'Dienst:\s+[VL]\s+(\d+)', t) │
│ print(fn, len(svcs), svcs[:10], svcs[-10:], 'unique',len(set(svcs))) │
│ print('missing duplicates', [x for x in sorted(set(svcs)) if svcs.count(x)>2][:10]) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ oud.pdf 143 ['4001', '4001', '4002', '4002', '4003', '4003', '4004', '4004', '4005', '4005'] ['4074', '4076', '4076', '4078', '4078', '4701', '4702', '4703', '4704', '4705'] unique 79 │
│ missing duplicates [] │
│ nieuw.pdf 155 ['4001', '4001', '4002', '4002', '4003', '4003', '4004', '4004', '4005', '4005'] ['4074', '4076', '4076', '4078', '4078', '4701', '4702', '4703', '4704', '4705'] unique 79 │
│ missing duplicates ['4024', '4040'] │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─── 🐍 • Vergelijk dienstnummerlijsten · (6ms) ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ sets={fn:set(re.findall(r'Dienst:\s+[VL]\s+(\d+)',t)) for fn,t in texts.items()} │
│ print('oud-only', sorted(sets['oud.pdf']-sets['nieuw.pdf'], key=int)) │
│ print('nieuw-only', sorted(sets['nieuw.pdf']-sets['oud.pdf'], key=int)) │
│ print('oud', sorted(sets['oud.pdf'], key=int)) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ oud-only [] │
│ nieuw-only [] │
│ oud ['4001', '4002', '4003', '4004', '4005', '4006', '4007', '4008', '4009', '4010', '4011', '4012', '4013', '4014', '4015', '4016', '4017', '4018', '4019', '4020', '4021', '4022', │
│ '4023', '4024', '4025', '4026', '4027', '4028', '4029', '4030', '4031', '4032', '4033', '4034', '4035', '4036', '4037', '4038', '4039', '4040', '4041', '4042', '4043', '4044', '4045', │
│ '4046', '4047', '4048', '4049', '4050', '4051', '4052', '4053', '4054', '4055', '4056', '4057', '4058', '4059', '4060', '4061', '4062', '4063', '4064', '4065', '4066', '4067', '4068', │
│ '4069', '4070', '4072', '4074', '4076', '4078', '4701', '4702', '4703', '4704', '4705'] │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Analyzing content differences
I need to compare the content differences between service pages by parsing each section and normalizing the text. I might remove dates and vehicle descriptions to identify variations in
times, routes, or driver runs. The PDFs likely have similar content, but I'll focus on operational changes and bus type text.
I think extracting sections by the service heading might help. I'll use Dienst: [V/L] num to capture text between headings and then compare it while accounting for metadata and whitespace.
Using line-level records could be beneficial for this!
Parsing service data from PDFs
I plan to parse each PDF into pages and service card blocks, with each dienst possibly spanning 2-3 pages. I'll compare exact data using external PDF text with programmatic normalization.
First, I'll gather headings, types, dates, and durations for all unique service instances.
Since the new layout merges some cards, the count of service headings might differ, so I’ll split based on Dienst:. I can utilize regex to capture occurrences and ensure that service 470x
might remain on single pages. I'll print the text for each occurrence to facilitate comparison!
Normalizing content for comparison
I need to normalize the data by replacing dates like 15/03/2026 and 16/08/2026, along with HASTUS timestamps. I’ll also replace specific vehicle labels like Elektrisch 12,2m M-net with a
generic term like VEH. I should keep in mind that the differences between new and old vehicles could indicate more significant content changes, possibly related to "materieel
modernisering."
It's essential for me to distinguish between substantive routes and bus models. Finally, I'll remove any extraneous formatting and whitespace to prepare for text comparisons in the first
sections!
╭─── 🐍 • Bepaal dienstkaartsegmenten · (16ms) ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ def service_sections(t): │
│ ms=list(re.finditer(r'Dienst:\s+([VL])\s+(\d+)',t)) │
│ out={} │
│ for i,m in enumerate(ms): │
│ key=m.group(1)+m.group(2) │
│ end=ms[i+1].start() if i+1<len(ms) else len(t) │
│ out.setdefault(key,[]).append(t[m.start():end]) │
│ return out │
│ secs={fn:service_sections(t) for fn,t in texts.items()} │
│ for k in sorted(secs['oud.pdf'], key=lambda x:int(x[1:])): │
│ print(k, len(secs['oud.pdf'][k]), len(secs['nieuw.pdf'][k]), [len(x) for x in secs['oud.pdf'][k]], [len(x) for x in secs['nieuw.pdf'][k]]) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ L4070 2 2 [1245, 691] [1084, 824] │
│ L4072 2 2 [1256, 823] [1110, 931] │
│ L4074 2 2 [1256, 818] [1103, 835] │
│ L4076 2 2 [1256, 558] [1104, 658] │
│ L4078 2 2 [1281, 64619] [1131, 64139] │
│ V4701 1 1 [462] [405] │
│ L4702 1 1 [462] [405] │
│ V4703 1 1 [462] [405] │
│ L4704 1 1 [462] [405] │
│ V4705 1 1 [3783] [3554] │
│ … 69 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Comparing services for extraction
I need to compare the actual services, and it looks like the text extraction layout has changed significantly, but the route and times are likely the same. I’ll have to programmatically
extract structured movements and compare the lines after normalizing and replacing whitespace. I think the V4010 service is a good place to start, especially since it might have sections
split differently in the new layout due to card merging. I need to take a closer look at that.
╭─── 🐍 • Inspecteer representatieve diensten · (8ms) ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for fn in ['oud.pdf','nieuw.pdf']: │
│ print('\n###',fn) │
│ for key in ['V4001','L4010','L4024','L4040','V4701']: │
│ print('\n--',key) │
│ print(secs[fn][key][0][:1800].replace('\f','\n---PAGE---\n')) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ Lijn Omloop Ritnr Vertrek Van Naar Aankomst │
│ 04:30 Reserve 12:30 │
│ │
│ │
│ │
│ │
│ HASTUS 2021 - dienstkaart_NoRefPlace 18/08/2026 8:23 215 │
│ │
│ ---PAGE--- │
│ MAANDAG T/M VRIJDAG │
│ … 327 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Understanding route data extraction
I need to figure out if all the route data is the same. Often, new extractions miss some lines due to page boundaries. But the content might be identical aside from vehicle type wording and
where "Aflosauto" is placed. I want to identify any non-vehicle differences. I’ll normalize vehicle strings and compare service sections while accounting for new formatting and page
segmentation. My plan includes creating a function to clean up the data by removing unnecessary lines, converting known bus model variants, collapsing whitespace, and using ratio
comparisons to identify discrepancies.
╭─── 🐍 ✘ Meet inhoudelijke overeenkomst · (9ms) ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ def norm(s): │
│ s=re.sub(r'15/03/2026|16/08/2026','DATE',s) │
│ s=re.sub(r'HASTUS 2021[^\n]*','',s) │
│ s=re.sub(r'\f','\n',s) │
│ # all known vehicle wording to one token, including spelling variant │
│ │
│ pats=[r'Elektrisch\s+12,2m\s+M-net',r'Elektrisch\s+13,5m\s+R-net',r'Electrisch\s+12,2m\s+M-net',r'Electrisch\s+13,5m\s+R-net',r'Elektrisch\s+12\s+meter\s+EBS\s+standaard\s+2024',r'Elektri │
│ sch\s+12\s+meter\s+R-net\s+2024',r'Electrisch\s+12\s+meter\s+EBS\s+standaard\s+2024',r'Electrisch\s+12\s+meter\s+R-net\s+2024'] │
│ for p in pats: │
│ s=re.sub(p,'BUS',s,flags=re.I) │
│ s=re.sub(r'\b(?:V|L)\s+\d{4}\b','SERVICE',s) │
│ s=re.sub(r'\s+',' ',s) │
│ return s.strip() │
│ from difflib import SequenceMatcher │
│ scores=[] │
│ for k in sorted(sets['oud.pdf'],key=lambda x:int(x[1:])): │
│ a=norm(' '.join(secs['oud.pdf'][k])); │
│ b=norm(' '.join(secs['nieuw.pdf'][k])) │
│ scores.append((SequenceMatcher(None,a,b).ratio(),k,len(a),len(b))) │
│ for x in sorted(scores): │
│ print(f'{x[1]} {x[0]:.3f} {x[2]}/{x[3]}') │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ Traceback (most recent call last): │
│ File "<cell>", line 14, in <module> │
│ KeyError: '4001' │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─── 🐍 • Meet inhoudelijke overeenkomst · (2.0s) ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ service_by_num={k[1:]:k for k in secs['oud.pdf']} │
│ scores=[] │
│ for n in sorted(service_by_num,key=int): │
│ k=service_by_num[n] │
│ a=norm(' '.join(secs['oud.pdf'][k])); │
│ b=norm(' '.join(secs['nieuw.pdf'][k])) │
│ scores.append((SequenceMatcher(None,a,b).ratio(),k,len(a),len(b))) │
│ for x in sorted(scores): │
│ print(f'{x[1]} {x[0]:.3f} {x[2]}/{x[3]}') │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ V4057 0.889 728/827 │
│ L4016 0.890 737/836 │
│ L4050 0.895 1065/993 │
│ L4702 0.895 190/154 │
│ L4704 0.895 190/154 │
│ V4701 0.895 190/154 │
│ V4703 0.895 190/154 │
│ L4076 0.905 1035/963 │
│ V4063 0.910 1231/1159 │
│ L4006 0.920 1407/1335 │
│ … 69 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Calculating token differences
I want to compute token differences per service while excluding certain phrases like vehicle terms and dates along with service headings and page numbers. I need to parse strings and map
complete text for each service. For extraction, I should focus on 4-digit numeric tokens, including service references, trip numbers, and material identifiers.
To compare counts after removing unwanted items, using PDF pages seems better. Each page text is specific, and I can look for the first "Dienst" heading to guide my extraction. I'll need to
check the service order and section lengths carefully.
╭─── 🐍 • Controleer laatste dienstsegmenten · (3ms) ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for fn in texts: │
│ print('\n',fn) │
│ ms=list(re.finditer(r'Dienst:\s+([VL])\s+(\d+)',texts[fn])) │
│ for i,m in enumerate(ms[-12:]): │
│ print(m.group(1)+m.group(2), m.start(), (ms[-12+i+1].start()-m.start() if i+1<len(ms[-12:]) else len(texts[fn])-m.start())) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ L4074 132517 835 │
│ L4076 133352 1104 │
│ L4076 134456 658 │
│ L4078 135114 1131 │
│ L4078 136245 64139 │
│ V4701 200384 405 │
│ L4702 200789 405 │
│ V4703 201194 405 │
│ L4704 201599 405 │
│ V4705 202004 3554 │
│ … 17 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─── 🐍 • Controleer ruwe PDF-tekst · (116ms) ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ raw=subprocess.run(['pdftotext','-raw','nieuw.pdf','-'],capture_output=True,text=True,check=True).stdout │
│ print(raw[:1800]) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ 13:03 - 21:25 │
│ Lijn Ritnr Vertrek Omloop Van Naar Aankomst │
│ Meenemen Electrisch 12 meter R-net 2024 │
│ 13:03 Opstaptijd 13:09 │
│ 13:09 Stekkeren 13:10 │
│ MAT 1824 13:10 Zdm Gar Zdm Zss 13:23 │
│ 391 1077 13:23 Zdm Zss Asd CS 14:11 │
│ 391 1074 14:17 Asd CS Zdm Zmc 14:51 │
│ MAT 14:51 Zdm ZmcZdm Zmc 14:54 │
│ 395 1084 14:56 Zdm ZmcAsd │
│ … 54 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─── 🐍 • Segmenteer ruwe dienstkaarten · (199ms) ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ rawtexts={fn:subprocess.run(['pdftotext','-raw',fn,'-'],capture_output=True,text=True,check=True).stdout for fn in ['oud.pdf','nieuw.pdf']} │
│ def raw_sections(t): │
│ ms=list(re.finditer(r'Zaandam, Garage ([VL]) (\d+)',t)) │
│ out={} │
│ for i,m in enumerate(ms): │
│ key=m.group(1)+m.group(2); │
│ end=ms[i+1].start() if i+1<len(ms) else len(t) │
│ out.setdefault(key,[]).append(t[m.start():end]) │
│ return out │
│ rsecs={fn:raw_sections(t) for fn,t in rawtexts.items()} │
│ print([(fn,len(x),list(x)[:3]) for fn,x in rsecs.items()]) │
│ print('L4078 sizes', [len(x) for x in rsecs['oud.pdf']['L4078']], [len(x) for x in rsecs['nieuw.pdf']['L4078']]) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ [('oud.pdf', 79, ['V4001', 'L4002', 'V4003']), ('nieuw.pdf', 79, ['V4001', 'L4002', 'V4003'])] │
│ L4078 sizes [921, 45763] [818, 46406] │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Normalizing data format
I need to clean up the raw data by removing unnecessary elements like headers, dates, and vehicle variants. It's important to eliminate HASTUS lines and page labels too. I’ll address line
breaks between the bus name and "voor dienst" and collapse any excess whitespace. All numbers should stay intact. I also need to remove generic lines like "Zaandam..." and ensure I keep the
line references. Finally, I'll compare using SequenceMatcher for accuracy.
╭─── 🐍 • Vergelijk ruwe dienstinhoud · (1.8s) ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ def normraw(s): │
│ s=re.sub(r'\f','\n',s) │
│ s=re.sub(r'HASTUS 2021[^\n]*','',s) │
│ s=re.sub(r'Ingangsdatum\s*:\s*(?:15/03/2026|16/08/2026)','Ingangsdatum',s) │
│ # normalize bus descriptions, allowing line breaks │
│ │
│ pats=[r'Elektrisch\s+12,2m\s+M-net',r'Elektrisch\s+13,5m\s+R-net',r'Electrisch\s+12,2m\s+M-net',r'Electrisch\s+13,5m\s+R-net',r'Elektrisch\s+12\s+meter\s+EBS\s+standaard\s+2024',r'Elektri │
│ sch\s+12\s+meter\s+R-net\s+2024',r'Electrisch\s+12\s+meter\s+EBS\s+standaard\s+2024',r'Electrisch\s+12\s+meter\s+R-net\s+2024'] │
│ for p in pats: │
│ s=re.sub(p,'BUS',s,flags=re.I) │
│ s=re.sub(r'\s+',' ',s) │
│ return s.strip() │
│ rscores=[] │
│ for k in sorted(rsecs['oud.pdf'],key=lambda x:int(x[1:])): │
│ a=normraw(' '.join(rsecs['oud.pdf'][k])); │
│ b=normraw(' '.join(rsecs['nieuw.pdf'][k])) │
│ rscores.append((SequenceMatcher(None,a,b).ratio(),k,len(a),len(b))) │
│ for x in sorted(rscores): │
│ print(f'{x[1]} {x[0]:.3f} {x[2]}/{x[3]}') │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ V4065 0.835 774/865 │
│ L4012 0.840 807/898 │
│ L4032 0.874 786/877 │
│ L4702 0.890 182/146 │
│ L4704 0.890 182/146 │
│ V4701 0.890 182/146 │
│ V4703 0.890 182/146 │
│ V4029 0.892 716/807 │
│ V4057 0.892 720/811 │
│ L4016 0.893 729/820 │
│ … 69 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Inspecting data ratios
I'm noticing that the ratios seem low, even though the values might be the same. It looks like the column order differs between the old and new datasets. The old raw data has "Lijn Ritnr
Vertrek Omloop Van Naar Aankomst," but I'm not sure if the new one is the same. I wonder why I'm getting a 0.5 ratio. I should check the differences in V4001 after normalizing to get more
clarity.
╭─── 🐍 • Analyseer eerste inhoudsverschil · (7ms) ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ from difflib import ndiff │
│ k='V4001'; │
│ a=normraw(' '.join(rsecs['oud.pdf'][k])); │
│ b=normraw(' '.join(rsecs['nieuw.pdf'][k])) │
│ print('OLD',a); │
│ print('\nNEW',b) │
│ print('\nDIFF') │
│ print('\n'.join(list(ndiff(a.split(),b.split()))[:250])) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ 12:25 │
│ - ZAANDAM │
│ - MAANDAG │
│ - T/M │
│ - VRIJDAG │
│ - ZAANDAM │
│ MAANDAG │
│ T/M │
│ VRIJDAG │
│ 8h22 │
│ … 236 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Analyzing data extraction
I need to eliminate generic words and focus on comparing numbers and stopping labels. I’m curious about potential missing old route rows. I'll compute a numeric token multiset after
stripping out bus words, dates, and HASTUS page numbers. I want to keep relevant times, service references, trip details, and material while removing unnecessary page numbers. Since I don't
expect substantive differences, extracting numeric tokens will help reveal any changes. I'll compare the numeric token counts for each service after removing duplicates and irrelevant
headers.
Analyzing data lines
I notice there's a line, like 1MAANDAG, that’s causing an issue with a numeric value of 1. So, I need to remove the HASTUS... line, which has the page number attached, and that’s good.
However, it looks like other entries like Zaandam don't have any numeric values associated. I should compute the numeric Counter differences for each service to ensure everything aligns
correctly. There’s a lot going on, so I want to keep this organized!
╭─── 🐍 • Detecteer gewijzigde tijden en nummers · (9ms) ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ from collections import Counter │
│ # Numeric tokens in normalized raw; remove known date and HASTUS lines first │
│ def numcounter(s): │
│ s=re.sub(r'HASTUS 2021[^\n]*','',s) │
│ s=re.sub(r'\d{2}/\d{2}/\d{4}','',s) │
│ return Counter(re.findall(r'\b\d+(?:[:.]\d+)?\b',s)) │
│ for k in sorted(rsecs['oud.pdf'],key=lambda x:int(x[1:])): │
│ a=numcounter(' '.join(rsecs['oud.pdf'][k])); │
│ b=numcounter(' '.join(rsecs['nieuw.pdf'][k])) │
│ diffa=a-b; │
│ diffb=b-a │
│ if diffa or diffb: │
│ print(k, 'old-only',diffa.most_common(15),'new-only',diffb.most_common(15)) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ V4069 old-only [('13', 4)] new-only [('2024', 6), ('12', 4)] │
│ L4070 old-only [('13', 2)] new-only [('2024', 5), ('12', 2)] │
│ L4072 old-only [('13', 2)] new-only [('2024', 6), ('12', 2)] │
│ L4074 old-only [('13', 1)] new-only [('2024', 4), ('12', 1)] │
│ L4076 old-only [] new-only [('2024', 4)] │
│ L4078 old-only [('13', 93), ('1732', 1)] new-only [('2024', 189), ('12', 93), ('4431', 1), ('4425', 1), ('8009', 1), ('4411', 1), ('17:16', 1), ('17:09', 1), ('07:30', 1), ('06:12', 1), │
│ ('06:52', 1), ('19:15', 1)] │
│ V4705 old-only [('16:43', 2), ('12:27', 2), ('14:27', 2), ('16:27', 2), ('16:39', 2), ('16:41', 2), ('15:43', 2), ('11:27', 2), ('13:27', 2), ('15:27', 2), ('15:39', 2), ('15:41', 2), │
│ ('17:43', 2), ('11:57', 2), ('13:57', 2)] new-only [('16:53', 2), ('12:37', 2), ('14:37', 2), ('16:37', 2), ('16:49', 2), ('16:51', 2), ('15:53', 2), ('11:37', 2), ('13:37', 2), ('15:37', │
│ 2), ('15:49', 2), ('15:51', 2), ('17:53', 2), ('12:07', 2), ('14:07', 2)] │
│ … 68 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Inspecting bus data changes
I’m looking at older bus data, particularly the old length is 13.5 meters and the new is 12 meters, which is significant. I need to normalize the bus labels and check for duplicates in the
service headings. The V4705 schedule has changed by +10 minutes, so I’ll really need to inspect that. I’ll also compare old and new records for L4062, checking for vehicle number changes
and any genuine differences. Overall, careful examination is key!
╭─── 🐍 • Vergelijk reservestation V4705 · (3ms) ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for fn in ['oud.pdf','nieuw.pdf']: │
│ print('\n###',fn) │
│ print('\n'.join(rsecs[fn]['V4705'][0].splitlines()[:120])) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ 11:23 Opstaptijd 11:29 │
│ MAT 1732 11:29 Zdm Gar Zdm Sta 11:40 │
│ 801 1208 11:40 Zdm Sta Zdm Sta 13:07 │
│ 13:07 Pauze 13:40 │
│ 801 1216 1732 13:40 Zdm Sta Zdm Sta 15:07 │
│ 15:07 Pauze 15:40 │
│ 801 1224 1732 15:40 Zdm Sta Zdm Sta 17:07 │
│ MAT 17:07 Zdm Sta Zdm Gar 17:19 │
│ 17:19 Afstaptijd 17:21 │
│ HASTUS 2021 - dienstkaart_NoRefPlace 18/08/2026 8:23 223 │
│ … 165 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Finding service labels
I need to find service labels like D 490x and P 490x. To achieve that, I can use the regex pattern Garage ([A-Z]) (\d+) which should help me extract all of them effectively. This regex
seems to match the format I'm looking for, capturing the letter and number components. Now, I just need to implement it and see if it works as expected! Let's give this a go and find those
service labels!
╭─── 🐍 • Inventariseer alle diensttypen · (3ms) ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for fn,t in rawtexts.items(): │
│ vals=re.findall(r'Zaandam, Garage ([A-Z]) (\d+)',t) │
│ print(fn,len(vals), sorted(set(a+b for a,b in vals), key=lambda x:int(x[1:]))) │
│ # all occurrences of D/P 49xx │
│ print(Counter(a+b for a,b in vals if a in 'DP')) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ 'L4040', 'V4041', 'L4042', 'V4043', 'L4044', 'V4045', 'L4046', 'V4047', 'L4048', 'V4049', 'L4050', 'V4051', 'L4052', 'V4053', 'L4054', 'V4055', 'L4056', 'V4057', 'L4058', 'V4059', │
│ 'L4060', 'V4061', 'L4062', 'V4063', 'L4064', 'V4065', 'L4066', 'V4067', 'L4068', 'V4069', 'L4070', 'L4072', 'L4074', 'L4076', 'L4078', 'D4201', 'D4203', 'D4205', 'D4207', 'D4209', │
│ 'G4401', 'G4403', 'G4405', 'G4407', 'G440… │
│ Counter({'D4201': 2, 'D4203': 2, 'D4205': 2, 'D4207': 2, 'D4209': 2, 'P4602': 1, 'D4901': 1, 'P4903': 1, 'D4905': 1, 'P4907': 1}) │
│ nieuw.pdf 211 ['V4001', 'L4002', 'V4003', 'L4004', 'V4005', 'L4006', 'V4007', 'L4008', 'V4009', 'L4010', 'V4011', 'L4012', 'V4013', 'L4014', 'V4015', 'L4016', 'V4017', 'L4018', 'V4019', │
│ 'L4020', 'V4021', 'L4022', 'V4023', 'L4024', 'V4025', 'L4026', 'V4027', 'L4028', 'V4029', 'L4030', 'V4031', 'L4032', 'V4033', 'L4034', 'V4035', 'L4036', 'V4037', 'L4038', 'V4039', │
│ 'L4040', 'V4041', 'L4042', 'V4043', 'L4044', 'V4045', 'L4046', 'V4047', 'L4048', 'V4049', 'L4050', 'V4051', 'L4052', 'V4053', 'L4054', 'V4055', 'L4056', 'V4057', 'L4058', 'V4059', │
│ 'L4060', 'V4061', 'L4062', 'V4063', 'L4064', 'V4065', 'L4066', 'V4067', 'L4068', 'V4069', 'L4070', 'L4072', 'L4074', 'L4076', 'L4078', 'D4201', 'D4203', 'D4205', 'D4207', 'D4209', │
│ 'G4401', 'G4403', 'G4405', 'G4407', 'G4… │
│ Counter({'D4201': 2, 'D4203': 2, 'D4205': 2, 'D4207': 2, 'D4209': 2, 'P4602': 1, 'D4901': 1, 'D4903': 1, 'D4905': 1, 'P4907': 1}) │
│ … 2 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─── 🐍 • Vergelijk alle dienstnummers · (3ms) ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ allsets={fn:set(a+b for a,b in re.findall(r'Zaandam, Garage ([A-Z]) (\d+)',t)) for fn,t in rawtexts.items()} │
│ print('old-only',sorted(allsets['oud.pdf']-allsets['nieuw.pdf'],key=lambda x:int(x[1:]))) │
│ print('new-only',sorted(allsets['nieuw.pdf']-allsets['oud.pdf'],key=lambda x:int(x[1:]))) │
│ print('common special',sorted((allsets['oud.pdf']&allsets['nieuw.pdf'])-set(re.findall(r'[VL]\d+', ' '.join([]))),key=lambda x:int(x[1:]))) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ old-only ['P4903'] │
│ new-only ['D4903'] │
│ common special ['V4001', 'L4002', 'V4003', 'L4004', 'V4005', 'L4006', 'V4007', 'L4008', 'V4009', 'L4010', 'V4011', 'L4012', 'V4013', 'L4014', 'V4015', 'L4016', 'V4017', 'L4018', 'V4019', │
│ 'L4020', 'V4021', 'L4022', 'V4023', 'L4024', 'V4025', 'L4026', 'V4027', 'L4028', 'V4029', 'L4030', 'V4031', 'L4032', 'V4033', 'L4034', 'V4035', 'L4036', 'V4037', 'L4038', 'V4039', │
│ 'L4040', 'V4041', 'L4042', 'V4043', 'L4044', 'V4045', 'L4046', 'V4047', 'L4048', 'V4049', 'L4050', 'V4051', 'L4052', 'V4053', 'L4054', 'V4055', 'L4056', 'V4057', 'L4058', 'V4059', │
│ 'L4060', 'V4061', 'L4062', 'V4063', 'L4064', 'V4065', 'L4066', 'V4067', 'L4068', 'V4069', 'L4070', 'L4072', 'L4074', 'L4076', 'L4078', 'D4201', 'D4203', 'D4205', 'D4207', 'D4209', │
│ 'G4401', 'G4403', 'G4405', 'G4407', 'G… │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Analyzing regex usage
I'm thinking about how to use regex to refine the data from lines. First, I’ll remove any header lines and metadata, and normalize vehicle descriptors to "BUS." I also need to get rid of
the "HASTUS" lines.
Then there's the issue of comparing old and new row orders since they are only differing in column order. I see that even if the order changes, the main content remains the same.
I'll consider using SequenceMatcher to compare lines while ignoring unnecessary elements.
╭─── 🐍 ✘ Vergelijk operationele regels · (6ms) ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ def canon_lines(sections): │
│ out=[] │
│ s='\n'.join(sections) │
│ for line in s.splitlines(): │
│ line=line.strip() │
│ if not line: │
│ continue │
│ if re.search(r'HASTUS|ZAANDAM|MAANDAG T/M VRIJDAG|Zaandam, Garage|Ingangsdatum|^Dienst:',line): │
│ continue │
│ if re.fullmatch(r'\d+h\d+',line): │
│ continue │
│ if re.match(r'^Lijn\b',line): │
│ continue │
│ # remove page form-feed remnants │
│ line=re.sub(r'\s+',' ',line) │
│ for p in pats: │
│ line=re.sub(p,'BUS',line,flags=re.I) │
│ # normalize bus length number fragments after failed split │
│ line=line.replace('13,5m M-net','BUS').replace('12,2m M-net','BUS').replace('13,5m R-net','BUS') │
│ line=re.sub(r'\s+',' ',line).strip() │
│ if line and line not in ('---',): │
│ out.append(line) │
│ return out │
│ clines={fn:{k:canon_lines(v) for k,v in rsecs[fn].items()} for fn in rsecs} │
│ for k in sorted(rsecs['oud.pdf'],key=lambda x:int(x[1:])): │
│ a=clines['oud.pdf'][k]; │
│ b=clines['nieuw.pdf'][k] │
│ # compare counters (layout lines may differ) │
│ if Counter(a)!=Counter(b): │
│ # count differences only for main keys │
│ print(k, 'old', list((Counter(a)-Counter(b)).elements())[:12], 'new', list((Counter(b)-Counter(a)).elements())[:12]) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ Traceback (most recent call last): │
│ File "<cell>", line 18, in <module> │
│ File "<cell>", line 12, in canon_lines │
│ NameError: name 'pats' is not defined. Did you mean: 'Path'? │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Defining scope issues
I need to clarify that in programming, local variables are accessible only within the function they're defined in, while global variables can be accessed from anywhere in the code. It's
crucial to distinguish this because if I mistakenly use a local variable outside its defined scope, I could run into errors. I’ll explore more about how to effectively manage variable scope
to avoid confusion and make my code cleaner. Let’s dive into this!
╭─── 🐍 • Vergelijk operationele regels · (42ms) ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ pats=[r'Elektrisch\s+12,2m\s+M-net',r'Elektrisch\s+13,5m\s+R-net',r'Electrisch\s+12,2m\s+M-net',r'Electrisch\s+13,5m\s+R-net',r'Elektrisch\s+12\s+meter\s+EBS\s+standaard\s+2024',r'Elektri │
│ sch\s+12\s+meter\s+R-net\s+2024',r'Electrisch\s+12\s+meter\s+EBS\s+standaard\s+2024',r'Electrisch\s+12\s+meter\s+R-net\s+2024'] │
│ def canon_lines(sections): │
│ out=[]; │
│ s='\n'.join(sections) │
│ for line in s.splitlines(): │
│ line=line.strip() │
│ if not line: │
│ continue │
│ if re.search(r'HASTUS|ZAANDAM|MAANDAG T/M VRIJDAG|Zaandam, Garage|Ingangsdatum|^Dienst:',line): │
│ continue │
│ if re.fullmatch(r'\d+h\d+',line) or re.match(r'^Lijn\b',line): │
│ continue │
│ line=re.sub(r'\s+',' ',line) │
│ for p in pats: │
│ line=re.sub(p,'BUS',line,flags=re.I) │
│ line=line.replace('13,5m M-net','BUS').replace('12,2m M-net','BUS').replace('13,5m R-net','BUS') │
│ line=re.sub(r'\s+',' ',line).strip() │
│ if line and line not in ('---',): │
│ out.append(line) │
│ return out │
│ clines={fn:{k:canon_lines(v) for k,v in rsecs[fn].items()} for fn in rsecs} │
│ for k in sorted(rsecs['oud.pdf'],key=lambda x:int(x[1:])): │
│ a=clines['oud.pdf'][k]; │
│ b=clines['nieuw.pdf'][k] │
│ if Counter(a)!=Counter(b): │
│ print(k, 'old', list((Counter(a)-Counter(b)).elements())[:12], 'new', list((Counter(b)-Counter(a)).elements())[:12]) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ voor', 'dienst 4054', 'BUS van dienst', '4022'] │
│ L4076 old ['BUS van dienst 4008', 'Meenemen BUS', 'BUS voor dienst 4062', 'BUS van dienst 4044'] new ['BUS van', 'BUS van', 'dienst 4008', 'Meenemen Elektrisch 12 meter EBS', 'standaard │
│ 2024', 'BUS voor', 'dienst 4062', 'dienst 4044'] │
│ L4078 old ['BUS van dienst 4303', 'Meenemen BUS', 'Meenemen BUS', 'Meenemen BUS', 'Meenemen BUS', 'Meenemen BUS', 'Meenemen BUS', 'Meenemen BUS', 'Meenemen BUS', 'Meenemen BUS', 'Meenemen │
│ BUS', 'Meenemen BUS'] new ['BUS van', 'BUS van', 'BUS van', 'BUS van', 'BUS van', 'BUS van', 'BUS van', 'BUS van', 'BUS van', 'BUS van', 'BUS van', 'BUS van'] │
│ V4705 old ['09:23 - 16:43', '801 1000 09:40 Zdm Sta Zdm Sta 10:57', '801 1006 1733 11:10 Zdm Sta Zdm Sta 12:27', '12:27 Pauze 13:10', '801 1014 1733 13:10 Zdm Sta Zdm Sta 14:27', '14:27 │
│ Pauze 15:10', '801 1022 1733 15:10 Zdm Sta Zdm Sta 16:27', 'MAT 16:27 Zdm Sta Zdm Gar 16:39', '16:39 Stekkeren 16:41', '16:41 Afstaptijd 16:43', '09:53 - 15:43', '801 1002 10:10 Zdm Sta │
│ Zdm Sta 11:27'] new ['09:23 - 16:53', '801 1200 09:40 Zdm Sta Zdm Sta 11:07', '801 1206 1733 11:10 Zdm Sta Zdm Sta 12:37', '12:37 Pauze 13:10', '801 1214 1733 13:10 Zdm Sta Zdm Sta │
│ 14:37', '14:37 Pauze 15:10', '801 1222 1733 15:10 Zdm Sta Zdm Sta 16:37', 'MAT 16:37 Zdm Sta Zdm Gar 16:49', '16:49 Stekkeren 16:51', '16:51 Afstaptijd 16:53', '09:53 - 15:53', '801 1202 │
│ 10:10 Zdm Sta Zdm Sta 11:… │
│ … 133 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Managing bus labels
I need to handle the new label for the bus: "Elektrisch 12 meter EBS standaard 2024" and set up a numeric counter. The previous number counter was problematic because it didn't remove old
labels, which led to issues with bus numbers. My plan is to work with bus patterns and remove any dates, especially from HASTUS. After that, I’ll compare everything to make sure it lines up
correctly.
╭─── 🐍 • Vergelijk cijfers zonder voertuigtypen · (19ms) ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ def data_numcounter(sections): │
│ s='\n'.join(sections) │
│ s=re.sub(r'HASTUS 2021[^\n]*','',s) │
│ s=re.sub(r'\d{2}/\d{2}/\d{4}','',s) │
│ for p in pats: │
│ s=re.sub(p,'',s,flags=re.I) │
│ return Counter(re.findall(r'\b\d+(?:[:.]\d+)?\b',s)) │
│ print('verschillen na verwijderen voertuigbenaming:') │
│ for k in sorted(rsecs['oud.pdf'],key=lambda x:int(x[1:])): │
│ a=data_numcounter(rsecs['oud.pdf'][k]); │
│ b=data_numcounter(rsecs['nieuw.pdf'][k]) │
│ if a!=b: │
│ print(k,'old',list((a-b).elements())[:30],'new',list((b-a).elements())[:30]) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ V4037 old [] new ['4037', '05:56', '13:26'] │
│ L4040 old [] new ['4040', '15:45', '23:55'] │
│ V4047 old [] new ['4047', '06:13', '12:56'] │
│ V4057 old [] new ['4057', '06:34', '12:34'] │
│ L4062 old ['1732'] new ['8009'] │
│ V4065 old [] new ['4065', '06:48', '13:52'] │
│ L4078 old ['1732'] new ['4431', '4425', '8009', '4411', '17:16', '17:09', '07:30', '06:12', '06:52', '19:15'] │
│ V4705 old ['16:43', '16:43', '1000', '10:57', '1006', '12:27', '12:27', '1014', '14:27', '14:27', '1022', '16:27', '16:27', '16:39', '16:39', '16:41', '16:41', '15:43', '15:43', '1002', │
│ '11:27', '11:27', '1010', '13:27', '13:27', '1018', '15:27', '15:27', '15:39', '15:39'] new ['16:53', '16:53', '1200', '11:07', '1206', '12:37', '12:37', '1214', '14:37', '14:37', '1222', │
│ '16:37', '16:37', '16:49', '16:49', '16:51', '16:51', '15:53', '15:53', '1202', '11:37', '11:37', '1210', '13:37', '13:37', '1218', '15:37', '15:37', '15:49', '15:49'] │
│ … 8 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─── 🐍 • Controleer numerieke mutaties · (20ms) ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ def data_numcounter(sections): │
│ s='\n'.join(sections) │
│ s=re.sub(r'HASTUS 2021[^\n]*','',s) │
│ s=re.sub(r'\d{2}/\d{2}/\d{4}','',s) │
│ s=re.sub(r'Zaandam, Garage[^\n]*','',s) │
│ s=re.sub(r'Dienst:\s*','',s) │
│ s=re.sub(r'\b\d+h\d+\b','',s) │
│ for p in pats: │
│ s=re.sub(p,'',s,flags=re.I) │
│ return Counter(re.findall(r'\b\d+(?:[:.]\d+)?\b',s)) │
│ for k in sorted(rsecs['oud.pdf'],key=lambda x:int(x[1:])): │
│ a=data_numcounter(rsecs['oud.pdf'][k]); │
│ b=data_numcounter(rsecs['nieuw.pdf'][k]) │
│ if a!=b: │
│ print(k,'old',list((a-b).elements())[:30],'new',list((b-a).elements())[:30]) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ V4037 old [] new ['05:56', '13:26'] │
│ L4040 old [] new ['15:45', '23:55'] │
│ V4047 old [] new ['06:13', '12:56'] │
│ V4057 old [] new ['06:34', '12:34'] │
│ L4062 old ['1732'] new ['8009'] │
│ V4065 old [] new ['06:48', '13:52'] │
│ L4078 old ['1732'] new ['8009', '17:16', '17:09', '07:30', '06:12', '06:52', '19:15'] │
│ V4705 old ['16:43', '16:43', '1000', '10:57', '1006', '12:27', '12:27', '1014', '14:27', '14:27', '1022', '16:27', '16:27', '16:39', '16:39', '16:41', '16:41', '15:43', '15:43', '1002', │
│ '11:27', '11:27', '1010', '13:27', '13:27', '1018', '15:27', '15:27', '15:39', '15:39'] new ['16:53', '16:53', '1200', '11:07', '1206', '12:37', '12:37', '1214', '14:37', '14:37', '1222', │
│ '16:37', '16:37', '16:49', '16:49', '16:51', '16:51', '15:53', '15:53', '1202', '11:37', '11:37', '1210', '13:37', '13:37', '1218', '15:37', '15:37', '15:49', '15:49'] │
│ … 7 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─── 🐍 • Controleer gewijzigde locaties en handoff-tekst · (30ms) ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ def wordcounter(sections): │
│ s='\n'.join(sections) │
│ s=re.sub(r'HASTUS 2021[^\n]*','',s) │
│ s=re.sub(r'\d{2}/\d{2}/\d{4}','',s) │
│ s=re.sub(r'Zaandam, Garage[^\n]*','',s) │
│ s=re.sub(r'Dienst:\s*','',s) │
│ s=re.sub(r'\b\d+h\d+\b','',s) │
│ for p in pats: │
│ s=re.sub(p,'',s,flags=re.I) │
│ # remove header labels and generic formatting │
│ s=re.sub(r'\b(?:MAANDAG|T/M|VRIJDAG|Lijn|Ritnr|Vertrek|Omloop|Van|Naar|Aankomst|Ingangsdatum|Opstaptijd|Afstaptijd|Stekkeren|Pauze|Reserve)\b','',s,flags=re.I) │
│ return Counter(re.findall(r'[A-Za-zÀ-ÿ]+',s.lower())) │
│ for k in sorted(rsecs['oud.pdf'],key=lambda x:int(x[1:])): │
│ a=wordcounter(rsecs['oud.pdf'][k]); │
│ b=wordcounter(rsecs['nieuw.pdf'][k]) │
│ # ignore BUS/Elektrisch fragments because patterns don't catch split variants │
│ da=a-b; │
│ db=b-a │
│ if da or db: │
│ print(k,'old',da.most_common(10),'new',db.most_common(10)) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Extracting bus information
I'm noticing that there are no alphabetic differences after vehicle removal, which is a good sign since it means all stop and annotation texts remain the same. Now, I need to extract the
specific old and new information for L4062 so I can accurately report the bus number. I want to make sure that I'm getting this right for clear communication. Let's keep focused on that
important detail!
╭─── 🐍 • Verifieer mutatie dienst L4062 · (4ms) ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for fn in ['oud.pdf','nieuw.pdf']: │
│ print('\n###',fn) │
│ s='\n'.join(rsecs[fn]['L4062']) │
│ for line in s.splitlines(): │
│ if '17:11' in line or '1732' in line or '8009' in line or 'Meenemen' in line: │
│ print(line) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ Meenemen Elektrisch 13,5m M-net │
│ 17:05 Opstaptijd 17:11 │
│ MAT 1732 17:11 Zdm Gar Zdm Vli 17:14 │
│ Meenemen Elektrisch 12,2m M-net │
│ │
│ ### nieuw.pdf │
│ Meenemen Elektrisch 13,5m M-net │
│ 17:05 Opstaptijd 17:11 │
│ MAT 8009 17:11 Zdm Gar Zdm Vli 17:14 │
│ Meenemen Elektrisch 12 meter EBS │
│ … 1 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─── 🐍 • Lees volledige mutatiecontext L4062 · (6ms) ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for fn in ['oud.pdf','nieuw.pdf']: │
│ print('\n###',fn) │
│ s='\n'.join(rsecs[fn]['L4062']) │
│ print(s[:3500]) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ Elektrisch 12 meter EBS standaard 2024 van │
│ dienst 4076 │
│ 23:08 Pauze 23:57 │
│ 69 1074 1706 23:57 Zdm Sta Ass Sta 00:44 │
│ 69 1077 00:45 Ass Sta Wmv Sta 01:03 │
│ MAT 01:03 Wmv StaZdm Gar 01:19 │
│ 01:19 Stekkeren 01:21 │
│ 01:21 Afstaptijd 01:23 │
│ HASTUS 2021 - dienstkaart_NoRefPlace 18/08/2026 8:23 126MAANDAG T/M VRIJDAG │
│ 8h42 │
│ … 82 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Investigating bus type changes
I’m looking into the new bus type labels and the changes in MAT numbers from 1732 to 8009. The MAT number seems to refer to "Materieel," which relates to vehicle assignment. I need to
explore the embedded D/P differences, though it looks like textual checks show no differences. I wonder if service types, like D4201, might have separate pages. Let’s gather and compare all
service types and create a mapping for clarity!
╭─── 🐍 • Toon volledige dienstinventaris · (6ms) ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for fn,t in rawtexts.items(): │
│ vals=sorted(set(a+b for a,b in re.findall(r'Zaandam, Garage ([A-Z]) (\d+)',t)),key=lambda x:int(x[1:])) │
│ print('\n',fn, len(vals)) │
│ print(' '.join(vals)) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ V4001 L4002 V4003 L4004 V4005 L4006 V4007 L4008 V4009 L4010 V4011 L4012 V4013 L4014 V4015 L4016 V4017 L4018 V4019 L4020 V4021 L4022 V4023 L4024 V4025 L4026 V4027 L4028 V4029 L4030 V4031 │
│ L4032 V4033 L4034 V4035 L4036 V4037 L4038 V4039 L4040 V4041 L4042 V4043 L4044 V4045 L4046 V4047 L4048 V4049 L4050 V4051 L4052 V4053 L4054 V4055 L4056 V4057 L4058 V4059 L4060 V4061 L4062 │
│ V4063 L4064 V4065 L4066 V4067 L4068 V4069 L4070 L4072 L4074 L4076 L4078 D4201 D4203 D4205 D4207 D4209 G4401 G4403 G4405 G4407 G4409 G4411 G4413 G4415 G4417 G4419 G4421 G4423 G4425 G4427 │
│ G4429 G4431 G4433 G4435 G4437 P4602 V4701 L4702 V4703 L4704 V4705 D4901 P4903 D4905 P4907 │
│ │
│ nieuw.pdf 108 │
│ V4001 L4002 V4003 L4004 V4005 L4006 V4007 L4008 V4009 L4010 V4011 L4012 V4013 L4014 V4015 L4016 V4017 L4018 V4019 L4020 V4021 L4022 V4023 L4024 V4025 L4026 V4027 L4028 V4029 L4030 V4031 │
│ L4032 V4033 L4034 V4035 L4036 V4037 L4038 V4039 L4040 V4041 L4042 V4043 L4044 V4045 L4046 V4047 L4048 V4049 L4050 V4051 L4052 V4053 L4054 V4055 L4056 V4057 L4058 V4059 L4060 V4061 L4062 │
│ V4063 L4064 V4065 L4066 V4067 L4068 V4069 L4070 L4072 L4074 L4076 L4078 D4201 D4203 D4205 D4207 D4209 G4401 G4403 G4405 G4407 G4409 G4411 G4413 G4415 G4417 G4419 G4421 G4423 G4425 G4427 │
│ G4429 G4431 G4433 G4435 G4437 P4602 V4701 L4702 V4703 L4704 V4705 D4901 D4903 D4905 P4907 │
│ … 1 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─── 🐍 • Vergelijk aanvang eindtijd en duur · (7ms) ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ allrkeys=sorted(set(rsecs['oud.pdf'])|set(rsecs['nieuw.pdf']),key=lambda x:int(x[1:])) │
│ def header(s): │
│ # first range after Ingangsdatum and duration possibly on line before │
│ m=re.search(r'Ingangsdatum\s*:\s*(?:\d{2}/\d{2}/\d{4})\s*\n?\s*(\d{2}:\d{2})\s*-\s*(\d{2}:\d{2})',s) │
│ if not m: │
│ m=re.search(r'Ingangsdatum[^\n]*\n?[^\n]*(\d{2}:\d{2})\s*-\s*(\d{2}:\d{2})',s) │
│ d=re.search(r'\b(\d+h\d+)\b',s) │
│ return (m.group(1),m.group(2)) if m else None, d.group(1) if d else None │
│ for k in allrkeys: │
│ ho,do=header(rsecs['oud.pdf'][k][0]); │
│ hn,dn=header(rsecs['nieuw.pdf'][k][0]) │
│ if (ho,do)!=(hn,dn): │
│ print(k, (ho,do),'->',(hn,dn)) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ L4012 (None, '8h13') -> (None, '7h28') │
│ L4016 (None, '8h16') -> (None, '7h36') │
│ L4018 (None, '8h16') -> (None, '6h56') │
│ V4029 (None, '8h01') -> (None, '6h24') │
│ L4032 (None, '8h07') -> (None, '6h19') │
│ V4037 (None, '8h47') -> (None, '7h30') │
│ V4047 (None, '8h46') -> (None, '6h43') │
│ V4057 (None, '8h03') -> (None, '6h00') │
│ V4065 (None, '7h20') -> (None, '7h04') │
│ V4705 (None, '7h20') -> (None, '7h30') │
│ … 1 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Investigating parsing issues
I'm looking into a parsing issue related to the regex layout. It seems the first line reads something like Ingangsdatum : ... 13:22 - ... but it’s all on the same line without a newline.
I’ll need to inspect both the old and new raw data at L4010 to get a better understanding. This may be crucial for resolving the current parsing problem I'm facing. Let's see what I can
find!
╭─── 🐍 • Controleer tijdkoppen · (4ms) ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for fn in ['oud.pdf','nieuw.pdf']: │
│ print(fn,repr(rsecs[fn]['L4010'][0][:180])) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ oud.pdf 'Zaandam, Garage L 4010\nIngangsdatum : 15/03/2026\nDienst:\n13:22 - 19:37\nLijn Ritnr Vertrek Omloop Van Naar Aankomst\nMeenemen Aflosauto\n13:22 Opstaptijd 13:28\nMAT 8005 13:28 │
│ Zdm Gar ' │
│ nieuw.pdf 'Zaandam, Garage L 4010\nIngangsdatum : 16/08/2026\nDienst:\n13:22 - 19:37\nLijn Ritnr Vertrek Omloop Van Naar Aankomst\nMeenemen Aflosauto\n13:22 Opstaptijd 13:28\nMAT 8005 │
│ 13:28 Zdm Gar ' │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Analyzing service discrepancies
I need to focus on detecting differences, particularly regarding the V4705 embedded data. It's possible that other service time changes weren't detected since there were no numeric counters
found after removing the headers. First, I should inspect all D/P/G special service records for differences in bus or mat times. My plan is to systematically compare changes in bus vehicle
types and produce an overview of key data points, like the ingangsdatum changes and similarities in driving patterns among the specified lines.
╭─── 🐍 • Tel voertuigbenamingen · (21ms) ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for fn,t in rawtexts.items(): │
│ print(fn) │
│ for pat in ['Elektrisch 12,2m M-net','Elektrisch 13,5m R-net','Elektrisch 13,5m M-net','Elektrisch 12 meter EBS standaard 2024','Elektrisch 12 meter R-net 2024','Electrisch 13,5m │
│ M-net']: │
│ print(pat, len(re.findall(pat,t,re.I))) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ Elektrisch 12 meter EBS standaard 2024 0 │
│ Elektrisch 12 meter R-net 2024 0 │
│ Electrisch 13,5m M-net 0 │
│ nieuw.pdf │
│ Elektrisch 12,2m M-net 0 │
│ Elektrisch 13,5m R-net 0 │
│ Elektrisch 13,5m M-net 22 │
│ Elektrisch 12 meter EBS standaard 2024 256 │
│ Elektrisch 12 meter R-net 2024 0 │
│ Electrisch 13,5m M-net 0 │
│ … 4 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Evaluating regex matching
I’m working on a regex that doesn’t seem to match "Electrisch" with just one "c" in a new context, and I also want to consider "12 meter R-net" related to this. I need to account for all
possible variants of the word. It’s important to get accurate counting to ensure everything aligns properly. Let's see how to adjust the regex pattern to capture that one “c” properly!
╭─── 🐍 • Tel nieuwe voertuigbenamingen · (17ms) ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for fn,t in rawtexts.items(): │
│ print('\n',fn) │
│ for pat in [r'(?:Elektrisch|Electrisch)\s+12\s+meter\s+EBS\s+standaard\s+2024',r'(?:Elektrisch|Electrisch)\s+12\s+meter\s+R-net\s+2024',r'(?:Elektrisch|Electrisch)\s+13,5m\s+M-net']: │
│ print(pat, len(re.findall(pat,t,re.I))) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ oud.pdf │
│ (?:Elektrisch|Electrisch)\s+12\s+meter\s+EBS\s+standaard\s+2024 0 │
│ (?:Elektrisch|Electrisch)\s+12\s+meter\s+R-net\s+2024 0 │
│ (?:Elektrisch|Electrisch)\s+13,5m\s+M-net 22 │
│ │
│ nieuw.pdf │
│ (?:Elektrisch|Electrisch)\s+12\s+meter\s+EBS\s+standaard\s+2024 296 │
│ (?:Elektrisch|Electrisch)\s+12\s+meter\s+R-net\s+2024 263 │
│ (?:Elektrisch|Electrisch)\s+13,5m\s+M-net 22 │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─── 🐍 • Verifieer concrete mutaties · (5ms) ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for fn,t in rawtexts.items(): │
│ for val in ['MAT 1732','MAT 8009','D 4903','P 4903','801 1000','801 1200']: │
│ print(fn,val,t.count(val)) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ oud.pdf D 4903 0 │
│ oud.pdf P 4903 1 │
│ oud.pdf 801 1000 1 │
│ oud.pdf 801 1200 0 │
│ nieuw.pdf MAT 1732 3 │
│ nieuw.pdf MAT 8009 2 │
│ nieuw.pdf D 4903 1 │
│ nieuw.pdf P 4903 0 │
│ nieuw.pdf 801 1000 0 │
│ nieuw.pdf 801 1200 1 │
│ … 2 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Investigating MAT assignments
I'm analyzing the MAT 1732, which seems to still appear in other services as an assigned vehicle, so it hasn't been wholly removed. I've noticed one occurrence of L4062 has changed. It
makes sense to compare all MAT assignments, not just L4062, since I found differences are only due to the same service sections. The new MAT 1732 shows a count of 3 compared to the old 5,
likely because of the layout change with L4062. I need to locate the relevant contexts.
╭─── 🐍 • Lokaliseer MAT-wijzigingen · (6ms) ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for fn,t in rawtexts.items(): │
│ print('\n',fn) │
│ for m in re.finditer(r'MAT (?:1732|8009)',t): │
│ print(t[max(0,m.start()-80):m.start()+100].replace('\n',' ')) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ Elektrisch 12,2m M-net voor dienst 4028 Elektrisch 13,5m M-net van dienst 4062 MAT 1732 17:35 Zdm Vli Zdm Gar 17:38 17:38 Stekkeren 17:40 17:40 Afstaptijd 17:42 HASTUS 2021 - dien │
│ Elektrisch 13,5m R-net voor dienst 4067 Elektrisch 13,5m M-net van dienst 4205 MAT 1732 10:06 Zdm Vli Zdm Gar 10:09 10:09 Stekkeren 10:11 10:11 Afstaptijd 10:13 Onbet. pauze GD Me │
│ Omloop Van Naar Aankomst Meenemen Elektrisch 13,5m M-net 11:23 Opstaptijd 11:29 MAT 1732 11:29 Zdm Gar Zdm Sta 11:40 801 1008 11:40 Zdm Sta Zdm Sta 12:57 12:57 Pauze 13:40 801 1016 │
│ │
│ nieuw.pdf │
│ Omloop Van Naar Aankomst Meenemen Elektrisch 13,5m M-net 17:05 Opstaptijd 17:11 MAT 8009 17:11 Zdm Gar Zdm Vli 17:14 Elektrisch 13,5m M-net voor dienst 4207 Elektrisch 12 meter EBS │
│ st Meenemen Elektrisch 13,5m M-net 09:13 Opstaptijd 09:19 09:19 Stekkeren 09:20 MAT 1732 09:20 Zdm Gar Zdm Vli 09:23 Elektrisch 13,5m M-net voor dienst 4431 Electrisch 12 meter R-n │
│ eter EBS standaard 2024 voor dienst 4028 Elektrisch 13,5m M-net van dienst 4062 MAT 8009 17:35 Zdm Vli Zdm Gar 17:38 17:38 Stekkeren 17:40 17:40 Afstaptijd 17:42 HASTUS 2021 - dien │
│ sch 12 meter R-net 2024 voor dienst 4067 Elektrisch 13,5m M-net van dienst 4205 MAT 1732 10:06 Zdm Vli Zdm Gar 10:09 10:09 Stekkeren 10:11 10:11 Afstaptijd 10:13 Onbet. pauze GD HA │
│ Omloop Van Naar Aankomst Meenemen Elektrisch 13,5m M-net 11:23 Opstaptijd 11:29 MAT 1732 11:29 Zdm Gar Zdm Sta 11:40 801 1208 11:40 Zdm Sta Zdm Sta 13:07 13:07 Pauze 13:40 801 1216 │
│ … 3 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Identifying service changes
I’m noticing there’s a new MAT 8009 at L4062 and possibly another service at L4078. The old MAT 1732 seems to be linked to L4078. It looks like MAT 1732 first operated at 17:35 under the
previous context, which possibly connects to L4078. So, for the MAT assignment, 1732 transitioning to 8009 occurs in two services: first in L4062, then likely in L4078. I need to use regex
to pinpoint the service numbers accurately.
╭─── 🐍 • Bepaal alle gewijzigde MAT-toewijzingen · (5ms) ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for fn,t in rawtexts.items(): │
│ print('\n',fn) │
│ for m in re.finditer(r'MAT (?:1732|8009)',t): │
│ prev=list(re.finditer(r'Zaandam, Garage ([A-Z]) (\d+)',t[:m.start()]))[-1] │
│ print(prev.group(1)+prev.group(2),m.group(0),t[m.start():m.start()+100].replace('\n',' ')) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ D4207 MAT 1732 MAT 1732 17:35 Zdm Vli Zdm Gar 17:38 17:38 Stekkeren 17:40 17:40 Afstaptijd 17:42 HASTUS 2021 - dien │
│ G4431 MAT 1732 MAT 1732 10:06 Zdm Vli Zdm Gar 10:09 10:09 Stekkeren 10:11 10:11 Afstaptijd 10:13 Onbet. pauze GD Me │
│ P4907 MAT 1732 MAT 1732 11:29 Zdm Gar Zdm Sta 11:40 801 1008 11:40 Zdm Sta Zdm Sta 12:57 12:57 Pauze 13:40 801 1016 │
│ │
│ nieuw.pdf │
│ L4062 MAT 8009 MAT 8009 17:11 Zdm Gar Zdm Vli 17:14 Elektrisch 13,5m M-net voor dienst 4207 Elektrisch 12 meter EBS │
│ D4205 MAT 1732 MAT 1732 09:20 Zdm Gar Zdm Vli 09:23 Elektrisch 13,5m M-net voor dienst 4431 Electrisch 12 meter R-n │
│ D4207 MAT 8009 MAT 8009 17:35 Zdm Vli Zdm Gar 17:38 17:38 Stekkeren 17:40 17:40 Afstaptijd 17:42 HASTUS 2021 - dien │
│ G4431 MAT 1732 MAT 1732 10:06 Zdm Vli Zdm Gar 10:09 10:09 Stekkeren 10:11 10:11 Afstaptijd 10:13 Onbet. pauze GD HA │
│ P4907 MAT 1732 MAT 1732 11:29 Zdm Gar Zdm Sta 11:40 801 1208 11:40 Zdm Sta Zdm Sta 13:07 13:07 Pauze 13:40 801 1216 │
│ … 3 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Analyzing vehicle circulation shift
I’ve noticed a connection between MAT 1732 and 8009 in L4062 and D4207. This might indicate a shift in vehicle circulation that I should mention. I need to look closer at the context of
D4207 as it might just reflect an assignment change rather than something more significant. It's important to clarify this to understand what's happening fully!
╭─── 🐍 ✘ Verifieer MAT-wijziging D4207 · (5ms) ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for fn in ['oud.pdf','nieuw.pdf']: │
│ print('\n###',fn) │
│ print('\n'.join(rsecs[fn]['D4207'][0].splitlines()[:100])) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ ### oud.pdf │
│ Traceback (most recent call last): │
│ File "<cell>", line 3, in <module> │
│ KeyError: 'D4207' │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─── 🐍 • Controleer D4207-segment · (6ms) ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ print([k for k in rsecs['oud.pdf'] if '420' in k]) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ [] │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─── 🐍 • Lees dienst D4207 · (3ms) ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ def raw_all_sections(t): │
│ ms=list(re.finditer(r'Zaandam, Garage ([A-Z]) (\d+)',t)) │
│ out={} │
│ for i,m in enumerate(ms): │
│ key=m.group(1)+m.group(2); │
│ end=ms[i+1].start() if i+1<len(ms) else len(t) │
│ out.setdefault(key,[]).append(t[m.start():end]) │
│ return out │
│ allsecs={fn:raw_all_sections(t) for fn,t in rawtexts.items()} │
│ for fn in ['oud.pdf','nieuw.pdf']: │
│ print('\n###',fn) │
│ print('\n'.join(allsecs[fn]['D4207'][0].splitlines()[:100])) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ Electrisch 12 meter R-net 2024 voor dienst │
│ 4425 │
│ Electrisch 12 meter R-net 2024 van dienst │
│ 4067 │
│ 391 1069 1811 12:48 Zdm Vli Asd CS 13:11 │
│ 391 1066 13:17 Asd CS Zdm Zmc 13:51 │
│ MAT 13:51 Zdm ZmcZdm Zmc 13:54 │
│ HASTUS 2021 - dienstkaart_NoRefPlace 18/08/2026 8:23 157 │
│ MAANDAG T/M VRIJDAG │
│ 7h32 │
│ … 52 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─── 🐍 • Controleer dienstkaartpagina's · (8ms) ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for fn in allsecs: │
│ print(fn, {k:len(v) for k,v in allsecs[fn].items() if k in ['D4207','L4062']}) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ oud.pdf {'L4062': 2, 'D4207': 2} │
│ nieuw.pdf {'L4062': 2, 'D4207': 2} │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─── 🐍 • Lees vervolg D4207 · (5ms) ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for fn in ['oud.pdf','nieuw.pdf']: │
│ print('\n###',fn) │
│ print('\n'.join(allsecs[fn]['D4207'][1].splitlines()[:80])) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ 111 1090 16:43 Mar Min Zdm Vli 17:33 │
│ Elektrisch 12 meter EBS standaard 2024 voor │
│ dienst 4028 │
│ Elektrisch 13,5m M-net van dienst 4062 │
│ MAT 8009 17:35 Zdm Vli Zdm Gar 17:38 │
│ 17:38 Stekkeren 17:40 │
│ 17:40 Afstaptijd 17:42 │
│ HASTUS 2021 - dienstkaart_NoRefPlace 18/08/2026 8:23 158 │
│ MAANDAG T/M VRIJDAG │
│ 6h48 │
│ … 36 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Comparing service cards
I’m looking at two service cards that share MAT 1732. The vehicle change might be consistent with old 8009 at L4062 and D4207. I’m wondering if there are any other MAT number differences
that I haven't captured because of repeated sections. It might help to create MAT assignment rows and compare the mappings based on the service context. I need to extract lines labeled MAT
[number] from all headings and compare that list keyed to service.
╭─── 🐍 ✘ Vergelijk materieeltoewijzingen · (8ms) ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for k in sorted(allsecs['oud.pdf'],key=lambda x:int(x[1:])): │
│ old=re.findall(r'MAT\s+(\d+)', '\n'.join(allsecs['oud.pdf'][k])) │
│ new=re.findall(r'MAT\s+(\d+)', '\n'.join(allsecs['nieuw.pdf'][k])) │
│ if old!=new: │
│ print(k,old,'->',new) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ L4062 ['1732', '19', '1719', '01'] -> ['8009', '19', '1719', '01'] │
│ D4207 ['8005', '10', '11', '13', '1732'] -> ['8005', '10', '11', '13', '8009'] │
│ Traceback (most recent call last): │
│ File "<cell>", line 3, in <module> │
│ KeyError: 'P4903' │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─── 🐍 • Bevestig alle materieelmutaties · (3ms) ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for k in sorted(set(allsecs['oud.pdf'])&set(allsecs['nieuw.pdf']),key=lambda x:int(x[1:])): │
│ old=re.findall(r'MAT\s+(\d+)', '\n'.join(allsecs['oud.pdf'][k])); │
│ new=re.findall(r'MAT\s+(\d+)', '\n'.join(allsecs['nieuw.pdf'][k])) │
│ if old!=new: │
│ print(k,old,'->',new) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ L4062 ['1732', '19', '1719', '01'] -> ['8009', '19', '1719', '01'] │
│ D4207 ['8005', '10', '11', '13', '1732'] -> ['8005', '10', '11', '13', '8009'] │
│ P4907 ['1732', '16'] -> ['1732', '17'] │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Clarifying vehicle specifications
I want to make sure I'm printing special sections clearly so that I can present exact values for the vehicle type. It’s important that everything is straightforward and accurate, especially
since this involves specifications. I need to pay attention to formatting and details to avoid any potential confusion. Each value should clearly reflect what it represents. Making it clean
will help users understand it better!
╭─── 🐍 • Lees gewijzigde 4900-diensten · (4ms) ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for kold,knew in [('D4901','D4901'),('P4903','D4903'),('D4905','D4905'),('P4907','P4907')]: │
│ print('\n###',kold,'oud') │
│ print('\n'.join(allsecs['oud.pdf'][kold][0].splitlines())) │
│ print('###',knew,'nieuw') │
│ print('\n'.join(allsecs['nieuw.pdf'][knew][0].splitlines())) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ 11:23 Opstaptijd 11:29 │
│ MAT 1732 11:29 Zdm Gar Zdm Sta 11:40 │
│ 801 1208 11:40 Zdm Sta Zdm Sta 13:07 │
│ 13:07 Pauze 13:40 │
│ 801 1216 1732 13:40 Zdm Sta Zdm Sta 15:07 │
│ 15:07 Pauze 15:40 │
│ 801 1224 1732 15:40 Zdm Sta Zdm Sta 17:07 │
│ MAT 17:07 Zdm Sta Zdm Gar 17:19 │
│ 17:19 Afstaptijd 17:21 │
│ HASTUS 2021 - dienstkaart_NoRefPlace 18/08/2026 8:23 223 │
│ … 154 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Calculating service durations
I need to accurately calculate durations for the 490 route. Old data shows D4901 had a duration of 7 hours and 20 minutes. But, after examining the footer, the next service, P4903, has a
duration of 5 hours and 50 minutes. So, it seems that 5h50 is likely for P4903, not D4901. It looks like the table should be based on the known headings. I'll make sure to check for any
schedule changes in the primary duties by comparing the routes.
Ensuring accuracy in evidence
I need to provide evidence in the final output without mentioning any scripts. I want to make sure I don't overlook any changes in D4207 or similar. It's important to compare all service
cards by analyzing the numeric counters after removing vehicle labels, page numbers, and unnecessary header metadata. Duplicate continuation headers might cause extra values, but I'll
detect those within the same set. I'll focus on known entries like L4062, D4207, and V4705. Let's see how this runs.
╭─── 🐍 • Controleer alle dienstkaarten · (20ms) ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ # Compare all typed service cards; remove known vehicle labels, headers, page markers, and durations. │
│ def card_num(sections): │
│ s='\n'.join(sections) │
│ s=re.sub(r'HASTUS 2021[^\n]*','',s); │
│ s=re.sub(r'\d{2}/\d{2}/\d{4}','',s) │
│ s=re.sub(r'Zaandam, Garage[^\n]*','',s); │
│ s=re.sub(r'Dienst:\s*','',s) │
│ s=re.sub(r'\b\d+h\d+\b','',s) │
│ for p in pats: │
│ s=re.sub(p,'',s,flags=re.I) │
│ return Counter(re.findall(r'\b\d+(?:[:.]\d+)?\b',s)) │
│ # account type rename P4903/D4903 │
│ for ko,kn in [('L4062','L4062'),('D4207','D4207'),('V4705','V4705')]: │
│ a=card_num(allsecs['oud.pdf'][ko]); │
│ b=card_num(allsecs['nieuw.pdf'][kn]); │
│ print(ko,'old-only',list((a-b).elements())[:25],'new-only',list((b-a).elements())[:25]) │
│ # all common cards show nonempty diffs abbreviated │
│ for k in sorted(set(allsecs['oud.pdf'])&set(allsecs['nieuw.pdf']),key=lambda x:(int(x[1:]),x)): │
│ a=card_num(allsecs['oud.pdf'][k]); │
│ b=card_num(allsecs['nieuw.pdf'][k]) │
│ if a!=b: │
│ print('DIFF',k,list((a-b).elements())[:8],list((b-a).elements())[:8]) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ DIFF V4057 [] ['06:34', '12:34'] │
│ DIFF L4062 ['1732'] ['8009'] │
│ DIFF V4065 [] ['06:48', '13:52'] │
│ DIFF D4207 ['1732'] ['8009'] │
│ DIFF G4411 [] ['06:12', '17:16'] │
│ DIFF G4425 [] ['06:52', '17:09'] │
│ DIFF G4431 [] ['07:30', '19:15'] │
│ DIFF D4901 ['16:43', '16:43', '1000', '10:57', '1006', '12:27', '12:27', '1014'] ['16:53', '16:53', '1200', '11:07', '1206', '12:37', '12:37', '1214'] │
│ DIFF D4905 ['17:43', '17:43', '1004', '11:57', '11:57', '1012', '13:57', '13:57'] ['17:53', '17:53', '1204', '12:07', '12:07', '1212', '14:07', '14:07'] │
│ DIFF P4907 ['17:11', '17:11', '1008', '12:57', '12:57', '1016', '14:57', '14:57'] ['17:21', '17:21', '1208', '13:07', '13:07', '1216', '15:07', '15:07'] │
│ … 13 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Inspecting page segmentation
I need to look into the G4411 entries and possibly G4425 and G4431 to check for any changes in actual times. It seems the second-page headings before the card might be causing duplicate
times in the new version. I'll also need to review the raw allsecs section to compare the old and new data. This should help me identify any issues with segmentation and duplication.
╭─── 🐍 • Controleer vermeende G-dienstverschillen · (1ms) ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ for k in ['G4411','G4425','G4431']: │
│ print('\n###',k) │
│ for fn in ['oud.pdf','nieuw.pdf']: │
│ print(fn, [x[:120].replace('\n',' | ') for x in allsecs[fn][k]]) │
├─── Output ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ nieuw.pdf ['Zaandam, Garage G 4425 | Ingangsdatum : 16/08/2026 | Dienst: | 06:52 - 17:09 | Lijn Ritnr Vertrek Omloop Van Naar Aankomst | Meene', 'Zaandam, Garage G 4425 | Ingangsdatum : │
│ 16/08/2026 | Dienst: | 06:52 - 17:09 | Lijn Ritnr Vertrek Omloop Van Naar Aankomst | Elect', 'Zaandam, Garage G 4425 | Ingangsdatum : 16/08/2026 | Dienst: | 06:52 - 17:09 | Lijn Ritnr │
│ Vertrek Omloop Van Naar Aankomst | MAT 8'] │
│ │
│ ### G4431 │
│ oud.pdf ['Zaandam, Garage G 4431 | Ingangsdatum : 15/03/2026 | Dienst: | 07:30 - 19:15 | Lijn Ritnr Vertrek Omloop Van Naar Aankomst | Meene', 'Zaandam, Garage G 4431 | Ingangsdatum : │
│ 15/03/2026 | Dienst: | 07:30 - 19:15 | Lijn Ritnr Vertrek Omloop Van Naar Aankomst | MAT 8'] │
│ nieuw.pdf ['Zaandam, Garage G 4431 | Ingangsdatum : 16/08/2026 | Dienst: | 07:30 - 19:15 | Lijn Ritnr Vertrek Omloop Van Naar Aankomst | Meene', 'Zaandam, Garage G 4431 | Ingangsdatum : │
│ 16/08/2026 | Dienst: | 07:30 - 19:15 | Lijn Ritnr Vertrek Omloop Van Naar Aankomst | Meene', 'Zaandam, Garage G 4431 | Ingangsdatum : 16/08/2026 | Dienst: | 07:30 - 19:15 | Lijn Ritnr │
│ Vertrek Omloop Van Naar Aankomst | 19:13'] │
│ … 10 more lines (ctrl+o to expand) │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Explaining dienstnummers vs ritnummers
I want to clarify the difference between "dienstnummers" and "ritnummers." My first thought is that "dienstnummers" usually relates to service numbers, while "ritnummers" typically refers
to ride or trip numbers. It can be important to understand these distinctions, especially if they're used in specific contexts like transportation or logistics. I wonder if there are
nuances in their use that I should also consider for a more complete explanation.
Hoofdconclusie
De dienstenpakketten bevatten inhoudelijk vrijwel dezelfde diensten. De ingangsdatum verschuift van 15 maart 2026 naar 16 augustus 2026.
Ik zie:
- geen numerieke dienstnummers die volledig zijn verdwenen;
- geen nieuwe numerieke dienstnummers;
- wel één wijziging in het diensttype: P 4903 is D 4903 geworden;
- wijzigingen in voertuigbenamingen;
- twee gewijzigde materieeltoewijzingen;
- vier onderliggende 4900-diensten met aangepaste ritnummers en eindtijden.
1. Voertuigbenamingen
In het nieuwe pakket zijn de voertuigtypen op de reguliere diensten aangepast:
┌────────────────────────┬────────────────────────────────────────┐
│ Oud pakket │ Nieuw pakket │
├────────────────────────┼────────────────────────────────────────┤
│ Elektrisch 12,2m M-net │ Elektrisch 12 meter EBS standaard 2024 │
├────────────────────────┼────────────────────────────────────────┤
│ Elektrisch 13,5m R-net │ Elektrisch 12 meter R-net 2024 │
└────────────────────────┴────────────────────────────────────────┘
De dienstpatronen zelf — lijnen, haltes, ritten en aansluitingen naar andere diensten — blijven daarbij gelijk.
De aanduiding Elektrisch 13,5m M-net blijft in de onderliggende 4900-diensten wel ongewijzigd staan.
2. Gewijzigde materieeltoewijzing
### L 4062
Bij het vertrek vanaf Zaandam Garage om 17:11:
- oud: MAT 1732
- nieuw: MAT 8009
Dezelfde materieelwissel komt terug bij:
### D 4207
Bij de rit vanaf Zdm Vli om 17:35:
- oud: MAT 1732
- nieuw: MAT 8009
De tijden en het traject blijven gelijk.
3. Wijzigingen in de onderliggende 4900-diensten
Deze diensten staan als onderdeel van het reservepakket rond V 4705. De reserve zelf blijft gelijk: 08:00–16:00.
┌────────────┬──────────────┬───────────────────┬───────────────────┬─────────────────────────────────────────────────────────────────┐
│ Dienst oud │ Dienst nieuw │ Oud │ Nieuw │ Belangrijkste wijziging │
├────────────┼──────────────┼───────────────────┼───────────────────┼─────────────────────────────────────────────────────────────────┤
│ D 4901 │ D 4901 │ 09:23–16:43, 7u20 │ 09:23–16:53, 7u30 │ Ritnummers 1000/1006/1014/1022 worden 1200/1206/1214/1222 │
├────────────┼──────────────┼───────────────────┼───────────────────┼─────────────────────────────────────────────────────────────────┤
│ P 4903 │ D 4903 │ 09:53–15:43, 5u50 │ 09:53–15:53, 6u00 │ Type P wordt D; ritnummers 1002/1010/1018 worden 1202/1210/1218 │
├────────────┼──────────────┼───────────────────┼───────────────────┼─────────────────────────────────────────────────────────────────┤
│ D 4905 │ D 4905 │ 10:23–17:43, 7u20 │ 10:23–17:53, 7u30 │ Ritnummers 1004/1012/1020/1026 worden 1204/1212/1220/1226 │
├────────────┼──────────────┼───────────────────┼───────────────────┼─────────────────────────────────────────────────────────────────┤
│ P 4907 │ P 4907 │ 11:23–17:11, 5u48 │ 11:23–17:21, 5u58 │ Ritnummers 1008/1016/1024 worden 1208/1216/1224 │
└────────────┴──────────────┴───────────────────┴───────────────────┴─────────────────────────────────────────────────────────────────┘
In alle vier gevallen:
- blijft de starttijd gelijk;
- blijft de route gelijk;
- schuiven de ritten en de eindtijd grotendeels 10 minuten op;
- veranderen de ritnummers van de 1000-reeks naar de 1200-reeks.
4. Dienstnummerinventaris
De reguliere dienstnummers zijn gelijk gebleven:
- 4001 t/m 4070, met dezelfde ontbrekende nummers;
- 4072, 4074, 4076 en 4078;
- de bijbehorende 4200-, 4400-, 4600- en 4700-diensten.
Voor de 4900-diensten geldt specifiek:
- 4901 blijft bestaan als D 4901;
- 4903 blijft numeriek bestaan, maar verandert van P 4903 naar D 4903;
- 4905 blijft D 4905;
- 4907 blijft P 4907.
### Samengevat
Er zijn dus geen dienstnummers met een volledig nieuw of verdwenen nummer. De inhoudelijke wijzigingen zijn vooral:
1. nieuwe voertuigclassificaties;
2. MAT 1732 vervangen door MAT 8009 op L 4062 en D 4207;
3. aangepaste 4900-diensten met 1200-ritnummers en tien minuten langere dienstduur;
4. P 4903 gewijzigd naar D 4903.