reqtable 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
reqtable/values.py ADDED
@@ -0,0 +1,192 @@
1
+ """Allowed values for table columns, defined by Value and Field records."""
2
+
3
+ VALUE_COLUMNS = ("Field", "Multiple")
4
+
5
+ VALUE_MODEL_JS = r"""
6
+ function valueFieldNames(headers,idColumn){
7
+ return {headers:new Set(headers),reserved:new Set([...Object.keys(traceFields),"Type","Field","Multiple",idColumn])};
8
+ }
9
+ function valueColumnProblem(name,names){
10
+ if(!name)return null;
11
+ if(names.reserved.has(name))return `“${name}” is a reserved column and cannot have defined values.`;
12
+ if(!names.headers.has(name))return `There is no “${name}” column.`;
13
+ return null;
14
+ }
15
+ function valueGroups(records,key){
16
+ const groups=new Map();
17
+ for(const record of records){
18
+ const name=key(record);
19
+ if(!name)continue;
20
+ const group=groups.get(name)??[];
21
+ group.push(record);
22
+ groups.set(name,group);
23
+ }
24
+ return groups;
25
+ }
26
+ function buildValueRules(records,headers,idColumn,issue){
27
+ const names=valueFieldNames(headers,idColumn),rules=new Map();
28
+ const all=[...records],fieldRecords=all.filter(record=>record.type==="Field");
29
+ const column=record=>record.row.Field?.trim()??"";
30
+ const target=record=>record.row.Name?.trim()??"";
31
+ for(const [name,group] of valueGroups(fieldRecords,target)){
32
+ const problem=valueColumnProblem(name,names);
33
+ if(problem){
34
+ for(const {id} of group)issue(id,"Name",problem);
35
+ continue;
36
+ }
37
+ if(group.length>1)for(const {id} of group)issue(id,"Name",`Another Field record describes ${name}.`);
38
+ const multiple=group[0].row.Multiple?.trim().toLowerCase()==="yes";
39
+ rules.set(name,{field:group[0],multiple,values:new Map(),aliases:new Map()});
40
+ }
41
+ for(const record of fieldRecords){
42
+ const {id,row}=record,multiple=row.Multiple?.trim()??"";
43
+ if(!target(record))issue(id,"Name","Enter the column this record describes.");
44
+ if(!row.Definition?.trim())issue(id,"Definition","Describe this column.");
45
+ if(multiple&&!/^(?:yes|no)$/i.test(multiple))issue(id,"Multiple","Enter Yes or No.");
46
+ }
47
+ const valueRecords=all.filter(record=>record.type==="Value");
48
+ for(const record of valueRecords){
49
+ const {id,row}=record,name=target(record),field=column(record);
50
+ if(!field)issue(id,"Field","Enter the column this value belongs to.");
51
+ else{
52
+ const problem=valueColumnProblem(field,names);
53
+ if(problem)issue(id,"Field",problem);
54
+ }
55
+ if(!name)issue(id,"Name","Enter the allowed value.");
56
+ if(!row.Definition?.trim())issue(id,"Definition","Explain what this value means.");
57
+ }
58
+ for(const [field,group] of valueGroups(valueRecords,column)){
59
+ if(valueColumnProblem(field,names))continue;
60
+ const rule=rules.get(field)??{field:null,multiple:false,values:new Map(),aliases:new Map()};
61
+ rules.set(field,rule);
62
+ const claims=new Map();
63
+ for(const record of group){
64
+ const name=target(record);
65
+ if(!name)continue;
66
+ const key=name.toLowerCase(),owner=claims.get(key);
67
+ if(owner&&owner!==record){
68
+ issue(record.id,"Name",`Another ${field} value is named “${name}”.`);
69
+ continue;
70
+ }
71
+ claims.set(key,record);
72
+ rule.values.set(name,record);
73
+ }
74
+ for(const record of group){
75
+ if(!target(record))continue;
76
+ for(const alias of traceIds(record.row.Aliases)){
77
+ const key=alias.toLowerCase(),owner=claims.get(key);
78
+ if(owner&&owner!==record){
79
+ issue(record.id,"Aliases",`“${alias}” is already a ${field} value name or alias.`);
80
+ continue;
81
+ }
82
+ if(!owner){
83
+ claims.set(key,record);
84
+ rule.aliases.set(alias,record);
85
+ }
86
+ }
87
+ }
88
+ }
89
+ for(const [field,rule] of rules)if(!rule.values.size)rules.delete(field);
90
+ for(const record of all){
91
+ if(record.type==="Value"||record.type==="Field")continue;
92
+ for(const [field,rule] of rules){
93
+ const cell=record.row[field]?.trim()??"";
94
+ if(!cell)continue;
95
+ const parts=rule.multiple?traceIds(cell):[cell],seen=new Set();
96
+ for(const part of parts){
97
+ const key=part.toLowerCase();
98
+ if(seen.has(key))issue(record.id,field,`“${part}” is listed more than once.`);
99
+ seen.add(key);
100
+ if(rule.values.has(part))continue;
101
+ const replaced=rule.aliases.get(part)??[...rule.aliases].find(([alias])=>alias.toLowerCase()===key)?.[1];
102
+ const canonical=replaced??[...rule.values.values()].find(value=>target(value).toLowerCase()===key);
103
+ if(canonical){
104
+ const spelling=replaced?"a replaced spelling":"spelled differently from the defined value";
105
+ issue(record.id,field,`“${part}” is ${spelling}; use “${target(canonical)}”.`);
106
+ }else{
107
+ issue(record.id,field,`“${part}” is not a defined ${field} value.`
108
+ +(!rule.multiple&&part.includes(";")?` ${field} allows one value.`:""));
109
+ }
110
+ }
111
+ }
112
+ }
113
+ return rules;
114
+ }
115
+ """
116
+
117
+ VALUE_EDIT_JS = r"""
118
+ const BOOLEAN_COLUMNS=new Map([["Auto Link","Term"],["Multiple","Field"]]);
119
+ function booleanApplies(column,type){return type!==undefined&&BOOLEAN_COLUMNS.get(column)===type;}
120
+ function booleanOn(value){return String(value??"").trim().toLowerCase()==="yes";}
121
+ function booleanToggle(value){return booleanOn(value)?"":"Yes";}
122
+ function observedSuggestions(rows,column){
123
+ const values=new Set();
124
+ for(const row of rows){
125
+ const value=String(row[column]??"").trimEnd();
126
+ if(!value)continue;
127
+ if(value.length>60||value.includes("\n"))return [];
128
+ values.add(value);
129
+ if(values.size>50)return [];
130
+ }
131
+ return [...values].sort((a,b)=>a.localeCompare(b)).map(value=>({value,detail:""}));
132
+ }
133
+ function suggestionSource(rule,rows,column){
134
+ if(!rule){
135
+ return {items:observedSuggestions(rows,column),defined:false,multiple:false};
136
+ }
137
+ const items=[...rule.values].map(([value,record])=>({value,detail:String(record.row.Definition??"").trim()}));
138
+ return {items,defined:true,multiple:rule.multiple};
139
+ }
140
+ function valueSegments(text){
141
+ return text.split(";").map(piece=>({text:piece.trim()}));
142
+ }
143
+ function segmentIndex(text,caret){
144
+ return text.slice(0,caret).split(";").length-1;
145
+ }
146
+ function matchSuggestions(source,text,caret){
147
+ let query=text,taken=new Set();
148
+ if(source.multiple){
149
+ const segments=valueSegments(text),at=segmentIndex(text,caret);
150
+ query=segments[at].text;
151
+ taken=new Set(segments.filter((_,i)=>i!==at).map(segment=>segment.text.toLocaleLowerCase()).filter(Boolean));
152
+ }
153
+ const needle=query.toLocaleLowerCase();
154
+ const open=source.items.filter(item=>item.value!==query&&!taken.has(item.value.toLocaleLowerCase()));
155
+ const prefix=open.filter(item=>item.value.toLocaleLowerCase().startsWith(needle));
156
+ if(!source.defined)return prefix;
157
+ return [...prefix,...open.filter(item=>!prefix.includes(item)&&item.value.toLocaleLowerCase().includes(needle))];
158
+ }
159
+ function chooseSuggestion(source,text,caret,value){
160
+ if(!source.multiple)return {text:value,caret:value.length,commit:true};
161
+ const parts=text.split(";").map(part=>part.trim());
162
+ parts[segmentIndex(text,caret)]=value;
163
+ const next=parts.filter(Boolean).join("; ");
164
+ return {text:next,caret:next.length,commit:false};
165
+ }
166
+ """
167
+
168
+ VALUE_RENAME_JS = r"""
169
+ function valueSlug(text){
170
+ return text.toUpperCase().replace(/[^A-Z0-9]+/g,"-").replace(/^-+|-+$/g,"");
171
+ }
172
+ function valueRecordId(field,name,taken){
173
+ const base=`VAL-${valueSlug(field)||"FIELD"}-${valueSlug(name)||"VALUE"}`;
174
+ let id=base;
175
+ for(let n=2;taken.has(id);n++)id=`${base}-${n}`;
176
+ return id;
177
+ }
178
+ function renameValueUses(rows,column,multiple,oldName,newName){
179
+ const changes=[];
180
+ for(const row of rows){
181
+ const type=String(row.Type??"").trim();
182
+ if(type==="Value"||type==="Field")continue;
183
+ const cell=String(row[column]??"");
184
+ const parts=multiple?cell.split(";").map(part=>part.trim()):[cell.trim()];
185
+ if(!parts.includes(oldName))continue;
186
+ changes.push({row,value:parts.map(part=>part===oldName?newName:part).filter(Boolean).join("; ")});
187
+ }
188
+ return changes;
189
+ }
190
+ """
191
+
192
+ VALUE_EDIT_JS += VALUE_RENAME_JS
reqtable/waivers.py ADDED
@@ -0,0 +1,109 @@
1
+ from __future__ import annotations
2
+
3
+ from dataclasses import asdict, dataclass
4
+ from typing import Any, Iterable, Sequence
5
+
6
+ from .core import ConfigError
7
+
8
+ _WAIVER_TYPES: dict[str, Any] = {
9
+ "check": str,
10
+ "reason": str,
11
+ "user": str,
12
+ "date": str,
13
+ "failing": list,
14
+ }
15
+
16
+
17
+ @dataclass(frozen=True)
18
+ class Waiver:
19
+ check: str
20
+ reason: str
21
+ user: str
22
+ date: str
23
+ failing: tuple[str, ...]
24
+
25
+ def to_dict(self) -> dict[str, Any]:
26
+ return {**asdict(self), "failing": list(self.failing)}
27
+
28
+ @classmethod
29
+ def from_dict(cls, data: Any) -> Waiver:
30
+ if not isinstance(data, dict) or set(data) != set(_WAIVER_TYPES):
31
+ raise ValueError("waiver has the wrong keys")
32
+ for key, kind in _WAIVER_TYPES.items():
33
+ if not isinstance(data[key], kind):
34
+ raise ValueError(f"waiver {key} has the wrong type")
35
+ if not data["reason"].strip():
36
+ raise ValueError("waiver reason is empty")
37
+ if not all(isinstance(item, str) for item in data["failing"]):
38
+ raise ValueError("waiver failing must hold strings")
39
+ return cls(
40
+ data["check"],
41
+ data["reason"],
42
+ data["user"],
43
+ data["date"],
44
+ tuple(data["failing"]),
45
+ )
46
+
47
+
48
+ def split_ids(values: Iterable[str]) -> list[str]:
49
+ return list(
50
+ dict.fromkeys(
51
+ part.strip()
52
+ for value in values
53
+ for part in value.split(",")
54
+ if part.strip()
55
+ )
56
+ )
57
+
58
+
59
+ def describe_failure(check: dict[str, Any]) -> str:
60
+ if check["error"]:
61
+ return f"{check['id']} cannot be evaluated ({check['error']}): {check['description']}"
62
+ return f"{check['id']} fails ({len(check['failing'])} of {check['total']}): {check['description']}"
63
+
64
+
65
+ def records(count: int) -> str:
66
+ return f"{count} record" if count == 1 else f"{count} records"
67
+
68
+
69
+ def plan_waivers(
70
+ result: dict[str, Any],
71
+ ids: Sequence[str],
72
+ reasons: Sequence[str],
73
+ user: str,
74
+ date: str,
75
+ ) -> list[Waiver]:
76
+ """Validate --waive against the evaluation and build the records. Raises ConfigError naming the first problem."""
77
+ if not ids:
78
+ return []
79
+ if not reasons or any(not reason.strip() for reason in reasons):
80
+ raise ConfigError("--waive needs --reason with the grounds for the waiver")
81
+ if len(reasons) not in (1, len(ids)):
82
+ raise ConfigError(
83
+ f"give one --reason for all waived checks, or one per check in the order they are named "
84
+ f"({len(ids)} checks, {len(reasons)} reasons)"
85
+ )
86
+ checks = {check["id"]: check for check in result["checks"]}
87
+ for check_id in ids:
88
+ check = checks.get(check_id)
89
+ if check is None:
90
+ raise ConfigError(
91
+ f"cannot waive {check_id!r}: gate {result['gate']} has no such check"
92
+ )
93
+ if check["enforcement"] != "strict":
94
+ raise ConfigError(
95
+ f"cannot waive {check_id}: it is advisory and does not block"
96
+ )
97
+ if not check["error"] and not check["failing"]:
98
+ raise ConfigError(f"cannot waive {check_id}: it is not failing")
99
+ paired = list(reasons) if len(reasons) == len(ids) else [reasons[0]] * len(ids)
100
+ return [
101
+ Waiver(
102
+ check_id,
103
+ reason.strip(),
104
+ user,
105
+ date,
106
+ tuple(checks[check_id].get("failing", ())),
107
+ )
108
+ for check_id, reason in zip(ids, paired)
109
+ ]