albert-memory 0.4.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.
- albert/__init__.py +3 -0
- albert/admin.py +532 -0
- albert/api.py +698 -0
- albert/automatic_memory_release.json +14 -0
- albert/benchmark.py +272 -0
- albert/benchmark_cli.py +37 -0
- albert/capture.py +1051 -0
- albert/capture_installer.py +1000 -0
- albert/capture_promotion.py +298 -0
- albert/capture_retention.py +72 -0
- albert/capture_sdk.py +558 -0
- albert/capture_security.py +79 -0
- albert/chunking.py +79 -0
- albert/classifier.py +263 -0
- albert/claude_adapter.py +357 -0
- albert/claude_lifecycle.py +418 -0
- albert/claude_package.json +19 -0
- albert/claude_plugin/.claude-plugin/plugin.json +11 -0
- albert/claude_plugin/.mcp.json +13 -0
- albert/claude_plugin/hooks/hooks.json +70 -0
- albert/clusters.py +140 -0
- albert/codex_adapter.py +308 -0
- albert/codex_hooks/hooks.json +49 -0
- albert/codex_lifecycle.py +485 -0
- albert/codex_package.json +19 -0
- albert/compatibility.py +121 -0
- albert/config.py +144 -0
- albert/console.py +508 -0
- albert/console_backends.py +236 -0
- albert/console_map.py +518 -0
- albert/console_ops.py +919 -0
- albert/credentials.py +616 -0
- albert/cursor_adapter.py +320 -0
- albert/cursor_hooks/hooks.json +11 -0
- albert/cursor_rules/albert-memory.mdc +11 -0
- albert/db.py +68 -0
- albert/embeddings.py +91 -0
- albert/graph.py +623 -0
- albert/graph_builders.py +879 -0
- albert/graph_cypher.py +669 -0
- albert/graph_store.py +376 -0
- albert/host_targets/claude-code.json +45 -0
- albert/host_targets/codex.json +45 -0
- albert/host_targets/openclaw.json +45 -0
- albert/host_targets.py +271 -0
- albert/links.py +428 -0
- albert/mcp_server.py +457 -0
- albert/memory_safety.py +111 -0
- albert/models.py +611 -0
- albert/openclaw_adapter.py +326 -0
- albert/openclaw_adapter_trust.json +5 -0
- albert/openclaw_package.json +22 -0
- albert/openclaw_plugin/index.js +135 -0
- albert/openclaw_plugin/openclaw.plugin.json +25 -0
- albert/openclaw_plugin/package.json +12 -0
- albert/portability.py +291 -0
- albert/provenance.py +105 -0
- albert/recorder.py +166 -0
- albert/release_gate.py +83 -0
- albert/schemas.py +617 -0
- albert/scope.py +26 -0
- albert/search.py +447 -0
- albert/security.py +150 -0
- albert/services.py +1316 -0
- albert/session_context.py +162 -0
- albert/trace_feed.py +165 -0
- albert/trace_writer.py +131 -0
- albert/tracing.py +75 -0
- albert/worker.py +202 -0
- albert/workspaces.py +256 -0
- albert_memory-0.4.0.dist-info/METADATA +554 -0
- albert_memory-0.4.0.dist-info/RECORD +74 -0
- albert_memory-0.4.0.dist-info/WHEEL +4 -0
- albert_memory-0.4.0.dist-info/entry_points.txt +14 -0
|
@@ -0,0 +1,298 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
import hashlib
|
|
4
|
+
import re
|
|
5
|
+
from uuid import UUID
|
|
6
|
+
|
|
7
|
+
from sqlalchemy import select
|
|
8
|
+
from sqlalchemy.orm import Session
|
|
9
|
+
|
|
10
|
+
from albert.memory_safety import apply_memory_safety
|
|
11
|
+
from albert.models import AuditEvent, CaptureCheckpoint, CaptureEvent, Episode, Memory, utcnow
|
|
12
|
+
from albert.recorder import current_recorder
|
|
13
|
+
|
|
14
|
+
_SENSITIVITY = ("public", "internal", "confidential", "restricted")
|
|
15
|
+
_DURABLE_CLASSES = {
|
|
16
|
+
"assistant_outcome",
|
|
17
|
+
"correction",
|
|
18
|
+
"decision",
|
|
19
|
+
"failure_summary",
|
|
20
|
+
"pre_compaction_checkpoint",
|
|
21
|
+
"selected_tool_outcome",
|
|
22
|
+
"user_goal",
|
|
23
|
+
"vcs_checkpoint",
|
|
24
|
+
}
|
|
25
|
+
_CHATTER = re.compile(
|
|
26
|
+
r"^(?:ok(?:ay)?|thanks?|hello|hi|got it|sounds good|working on it|done)[.!\s]*$", re.I
|
|
27
|
+
)
|
|
28
|
+
# A user prompt that only steers the current turn ("thanks, keep going") states
|
|
29
|
+
# nothing worth remembering; anything with its own content is promoted.
|
|
30
|
+
_CONTINUATION = re.compile(
|
|
31
|
+
r"^(?:(?:ok(?:ay)?|thanks?|thank you|great|cool|yes|sure)[,.!\s]+)*(?:please\s+)?"
|
|
32
|
+
r"(?:keep (?:going|working)|continue|carry on|go ahead|proceed)"
|
|
33
|
+
r"(?:\s+(?:on|with)\s+(?:this|that|it)(?:\s+task)?)?[.!\s]*$",
|
|
34
|
+
re.I,
|
|
35
|
+
)
|
|
36
|
+
_PROCEDURE = re.compile(r"\b(?:steps?|procedure|runbook|how to|first.+then)\b", re.I | re.S)
|
|
37
|
+
_LESSON = re.compile(r"\b(?:lesson|learned|root cause|failed because|avoid)\b", re.I)
|
|
38
|
+
_CLAIM_PREFIX = re.compile(r"^(?:correction|decision|fact)\s*:\s*", re.I)
|
|
39
|
+
_CLAIM_SUBJECT = re.compile(
|
|
40
|
+
r"^(.+?)\s+(?:is|are|was|were|should be|must be)\s+\S+", re.I
|
|
41
|
+
)
|
|
42
|
+
|
|
43
|
+
|
|
44
|
+
def _normalized(content: str) -> str:
|
|
45
|
+
return " ".join(content.casefold().split())
|
|
46
|
+
|
|
47
|
+
|
|
48
|
+
def _claim_subject(content: str) -> str | None:
|
|
49
|
+
claim = _CLAIM_PREFIX.sub("", content.strip())
|
|
50
|
+
match = _CLAIM_SUBJECT.match(claim)
|
|
51
|
+
return _normalized(match.group(1)) if match else None
|
|
52
|
+
|
|
53
|
+
|
|
54
|
+
def _memory_type(event: CaptureEvent) -> str:
|
|
55
|
+
if event.event_class == "decision":
|
|
56
|
+
return "decision"
|
|
57
|
+
if event.event_class == "failure_summary" or _LESSON.search(event.content):
|
|
58
|
+
return "lesson"
|
|
59
|
+
if _PROCEDURE.search(event.content):
|
|
60
|
+
return "procedure"
|
|
61
|
+
if event.event_class in {"vcs_checkpoint", "pre_compaction_checkpoint"}:
|
|
62
|
+
return "project_state"
|
|
63
|
+
return "fact"
|
|
64
|
+
|
|
65
|
+
|
|
66
|
+
def _fingerprint(event: CaptureEvent) -> str:
|
|
67
|
+
material = f"{_memory_type(event)}\0{_normalized(event.content)}"
|
|
68
|
+
return hashlib.sha256(material.encode()).hexdigest()
|
|
69
|
+
|
|
70
|
+
|
|
71
|
+
def _durable(event: CaptureEvent) -> bool:
|
|
72
|
+
content = event.content.strip()
|
|
73
|
+
return bool(
|
|
74
|
+
event.event_class in _DURABLE_CLASSES
|
|
75
|
+
and len(content) >= 12
|
|
76
|
+
and not _CHATTER.match(content)
|
|
77
|
+
and not (event.event_class == "user_goal" and _CONTINUATION.match(content))
|
|
78
|
+
)
|
|
79
|
+
|
|
80
|
+
|
|
81
|
+
def _promotion_metadata(
|
|
82
|
+
checkpoint: CaptureCheckpoint, event: CaptureEvent, fingerprint: str
|
|
83
|
+
) -> dict[str, object]:
|
|
84
|
+
return {
|
|
85
|
+
"automatic_capture_promotion": True,
|
|
86
|
+
"capture_checkpoint_id": str(checkpoint.id),
|
|
87
|
+
"capture_session_id": str(checkpoint.session_id),
|
|
88
|
+
"capture_event_id": str(event.id),
|
|
89
|
+
"capture_event_sequence": event.sequence,
|
|
90
|
+
"capture_event_class": event.event_class,
|
|
91
|
+
"capture_profile_key": event.profile_key,
|
|
92
|
+
"capture_profile_version": event.profile_version,
|
|
93
|
+
"capture_source_trust": event.source_trust,
|
|
94
|
+
"capture_retention_days": event.retention_days,
|
|
95
|
+
"capture_derivative_policy": event.derivative_policy,
|
|
96
|
+
"capture_promotion_fingerprint": fingerprint,
|
|
97
|
+
"provenance": event.provenance,
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
|
|
101
|
+
def _existing_canonical(session: Session, event: CaptureEvent, fingerprint: str) -> Memory | None:
|
|
102
|
+
candidates = session.scalars(
|
|
103
|
+
select(Memory).where(
|
|
104
|
+
Memory.organization_id == event.organization_id,
|
|
105
|
+
Memory.workspace_id == event.workspace_id,
|
|
106
|
+
Memory.owner_principal_id == event.owner_principal_id,
|
|
107
|
+
Memory.status == "active",
|
|
108
|
+
)
|
|
109
|
+
)
|
|
110
|
+
return next(
|
|
111
|
+
(
|
|
112
|
+
memory
|
|
113
|
+
for memory in candidates
|
|
114
|
+
if (memory.metadata_ or {}).get("capture_promotion_fingerprint") == fingerprint
|
|
115
|
+
),
|
|
116
|
+
None,
|
|
117
|
+
)
|
|
118
|
+
|
|
119
|
+
|
|
120
|
+
def _event_memory(session: Session, event: CaptureEvent) -> Memory | None:
|
|
121
|
+
if event.derived_memory_id is not None:
|
|
122
|
+
memory = session.get(Memory, event.derived_memory_id)
|
|
123
|
+
if memory is not None:
|
|
124
|
+
return memory
|
|
125
|
+
return session.scalar(
|
|
126
|
+
select(Memory).where(Memory.episode_id == event.episode_id, Memory.status == "active")
|
|
127
|
+
)
|
|
128
|
+
|
|
129
|
+
|
|
130
|
+
def _discard_memory(session: Session, event: CaptureEvent, memory: Memory | None) -> None:
|
|
131
|
+
episode = session.get(Episode, event.episode_id) if event.episode_id else None
|
|
132
|
+
if episode is not None:
|
|
133
|
+
episode.extra = {**episode.extra, "capture_promotion_decision": "discard"}
|
|
134
|
+
if memory is not None and memory.status != "deleted":
|
|
135
|
+
from albert.services import _scrub_memory
|
|
136
|
+
|
|
137
|
+
_scrub_memory(session, memory, utcnow())
|
|
138
|
+
event.derived_memory_id = None
|
|
139
|
+
|
|
140
|
+
|
|
141
|
+
def _supersede_previous(session: Session, event: CaptureEvent, memory: Memory) -> None:
|
|
142
|
+
if event.event_class != "correction":
|
|
143
|
+
return
|
|
144
|
+
subject = _claim_subject(event.content)
|
|
145
|
+
if subject is None:
|
|
146
|
+
return
|
|
147
|
+
candidates = session.execute(
|
|
148
|
+
select(Memory, CaptureEvent)
|
|
149
|
+
.join(CaptureEvent, CaptureEvent.derived_memory_id == Memory.id)
|
|
150
|
+
.where(
|
|
151
|
+
CaptureEvent.session_id == event.session_id,
|
|
152
|
+
CaptureEvent.sequence < event.sequence,
|
|
153
|
+
Memory.status == "active",
|
|
154
|
+
Memory.id != memory.id,
|
|
155
|
+
)
|
|
156
|
+
.order_by(CaptureEvent.sequence.desc())
|
|
157
|
+
).all()
|
|
158
|
+
previous = next(
|
|
159
|
+
(
|
|
160
|
+
candidate_memory
|
|
161
|
+
for candidate_memory, candidate_event in candidates
|
|
162
|
+
if _claim_subject(candidate_event.content) == subject
|
|
163
|
+
),
|
|
164
|
+
None,
|
|
165
|
+
)
|
|
166
|
+
if previous is None:
|
|
167
|
+
return
|
|
168
|
+
previous.status = "superseded"
|
|
169
|
+
previous.valid_until = event.occurred_at
|
|
170
|
+
previous.metadata_ = {
|
|
171
|
+
**(previous.metadata_ or {}),
|
|
172
|
+
"superseded_by_memory_id": str(memory.id),
|
|
173
|
+
"superseded_at": event.occurred_at.isoformat(),
|
|
174
|
+
"contradiction_flagged": True,
|
|
175
|
+
"contradiction_memory_ids": [str(memory.id)],
|
|
176
|
+
}
|
|
177
|
+
memory.metadata_ = {
|
|
178
|
+
**(memory.metadata_ or {}),
|
|
179
|
+
"supersedes_memory_id": str(previous.id),
|
|
180
|
+
"contradiction_flagged": True,
|
|
181
|
+
"contradiction_memory_ids": [str(previous.id)],
|
|
182
|
+
}
|
|
183
|
+
|
|
184
|
+
|
|
185
|
+
def promote_capture_checkpoint(session: Session, checkpoint_id: UUID) -> None:
|
|
186
|
+
checkpoint = session.get(CaptureCheckpoint, checkpoint_id)
|
|
187
|
+
if checkpoint is None or checkpoint.deleted_at is not None:
|
|
188
|
+
return
|
|
189
|
+
if checkpoint.promotion_status == "complete":
|
|
190
|
+
return
|
|
191
|
+
checkpoint.promotion_status = "running"
|
|
192
|
+
checkpoint.promotion_error = None
|
|
193
|
+
session.commit()
|
|
194
|
+
|
|
195
|
+
checkpoint = session.get(CaptureCheckpoint, checkpoint_id)
|
|
196
|
+
assert checkpoint is not None
|
|
197
|
+
prior_sequence = session.scalar(
|
|
198
|
+
select(CaptureCheckpoint.through_sequence)
|
|
199
|
+
.where(
|
|
200
|
+
CaptureCheckpoint.session_id == checkpoint.session_id,
|
|
201
|
+
CaptureCheckpoint.through_sequence < checkpoint.through_sequence,
|
|
202
|
+
CaptureCheckpoint.deleted_at.is_(None),
|
|
203
|
+
)
|
|
204
|
+
.order_by(CaptureCheckpoint.through_sequence.desc())
|
|
205
|
+
.limit(1)
|
|
206
|
+
) or 0
|
|
207
|
+
events = list(
|
|
208
|
+
session.scalars(
|
|
209
|
+
select(CaptureEvent)
|
|
210
|
+
.where(
|
|
211
|
+
CaptureEvent.session_id == checkpoint.session_id,
|
|
212
|
+
CaptureEvent.sequence > prior_sequence,
|
|
213
|
+
CaptureEvent.sequence <= checkpoint.through_sequence,
|
|
214
|
+
CaptureEvent.deleted_at.is_(None),
|
|
215
|
+
CaptureEvent.organization_id == checkpoint.organization_id,
|
|
216
|
+
CaptureEvent.workspace_id == checkpoint.workspace_id,
|
|
217
|
+
CaptureEvent.owner_principal_id == checkpoint.owner_principal_id,
|
|
218
|
+
)
|
|
219
|
+
.order_by(CaptureEvent.sequence)
|
|
220
|
+
)
|
|
221
|
+
)
|
|
222
|
+
promoted: list[Memory] = []
|
|
223
|
+
for event in events:
|
|
224
|
+
memory = _event_memory(session, event)
|
|
225
|
+
if not _durable(event):
|
|
226
|
+
_discard_memory(session, event, memory)
|
|
227
|
+
continue
|
|
228
|
+
if memory is None:
|
|
229
|
+
from albert.services import enrich_episode
|
|
230
|
+
|
|
231
|
+
enrich_episode(session, event.episode_id)
|
|
232
|
+
memory = _event_memory(session, event)
|
|
233
|
+
if memory is None:
|
|
234
|
+
raise RuntimeError(f"capture event {event.id} has no derived memory")
|
|
235
|
+
fingerprint = _fingerprint(event)
|
|
236
|
+
canonical = _existing_canonical(session, event, fingerprint)
|
|
237
|
+
if canonical is not None and canonical.id != memory.id:
|
|
238
|
+
_discard_memory(session, event, memory)
|
|
239
|
+
event.derived_memory_id = canonical.id
|
|
240
|
+
promoted.append(canonical)
|
|
241
|
+
continue
|
|
242
|
+
memory.memory_type = _memory_type(event)
|
|
243
|
+
memory.sensitivity = max(
|
|
244
|
+
memory.sensitivity, event.sensitivity, key=_SENSITIVITY.index
|
|
245
|
+
)
|
|
246
|
+
memory.valid_from = event.occurred_at
|
|
247
|
+
memory.metadata_ = {
|
|
248
|
+
**(memory.metadata_ or {}),
|
|
249
|
+
**_promotion_metadata(checkpoint, event, fingerprint),
|
|
250
|
+
}
|
|
251
|
+
memory.confidence, memory.metadata_ = apply_memory_safety(
|
|
252
|
+
memory.content,
|
|
253
|
+
memory.confidence,
|
|
254
|
+
memory.metadata_,
|
|
255
|
+
default_trust=event.source_trust,
|
|
256
|
+
)
|
|
257
|
+
episode = session.get(Episode, event.episode_id) if event.episode_id else None
|
|
258
|
+
if episode is not None:
|
|
259
|
+
episode.extra = {**episode.extra, "capture_promotion_decision": "promote"}
|
|
260
|
+
event.derived_memory_id = memory.id
|
|
261
|
+
_supersede_previous(session, event, memory)
|
|
262
|
+
promoted.append(memory)
|
|
263
|
+
|
|
264
|
+
unique = {memory.id: memory for memory in promoted}
|
|
265
|
+
checkpoint.derived_memory_id = promoted[-1].id if promoted else None
|
|
266
|
+
checkpoint.metadata_ = {
|
|
267
|
+
**checkpoint.metadata_,
|
|
268
|
+
"promoted_memory_ids": [str(memory_id) for memory_id in unique],
|
|
269
|
+
"promoted_count": len(unique),
|
|
270
|
+
"discarded_count": len(events) - len(promoted),
|
|
271
|
+
}
|
|
272
|
+
checkpoint.promotion_status = "complete"
|
|
273
|
+
checkpoint.promotion_error = None
|
|
274
|
+
session.add(
|
|
275
|
+
AuditEvent(
|
|
276
|
+
organization_id=checkpoint.organization_id,
|
|
277
|
+
workspace_id=checkpoint.workspace_id,
|
|
278
|
+
principal_id=checkpoint.owner_principal_id,
|
|
279
|
+
event_type="capture.checkpoint.completed",
|
|
280
|
+
resource_type="capture_checkpoint",
|
|
281
|
+
resource_id=str(checkpoint.id),
|
|
282
|
+
detail={
|
|
283
|
+
"through_sequence": checkpoint.through_sequence,
|
|
284
|
+
"promoted_count": len(unique),
|
|
285
|
+
"discarded_count": len(events) - len(promoted),
|
|
286
|
+
},
|
|
287
|
+
)
|
|
288
|
+
)
|
|
289
|
+
session.commit()
|
|
290
|
+
recorder = current_recorder()
|
|
291
|
+
if recorder is not None:
|
|
292
|
+
recorder.note(
|
|
293
|
+
capture_stage="consolidation",
|
|
294
|
+
checkpoint_id=str(checkpoint.id),
|
|
295
|
+
checkpoint_status="complete",
|
|
296
|
+
promoted_count=len(unique),
|
|
297
|
+
discarded_count=len(events) - len(promoted),
|
|
298
|
+
)
|
|
@@ -0,0 +1,72 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from datetime import datetime, timedelta
|
|
4
|
+
|
|
5
|
+
from sqlalchemy import or_, select
|
|
6
|
+
from sqlalchemy.orm import Session
|
|
7
|
+
|
|
8
|
+
from albert.models import CaptureCheckpoint, CaptureEvent, Episode, Memory, utcnow
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
def _expire_event(session: Session, event: CaptureEvent, now: datetime) -> None:
|
|
12
|
+
if event.deleted_at is not None:
|
|
13
|
+
return
|
|
14
|
+
from albert.services import _scrub_memory, forget_episode_graph
|
|
15
|
+
|
|
16
|
+
memories = list(
|
|
17
|
+
session.scalars(
|
|
18
|
+
select(Memory).where(
|
|
19
|
+
or_(Memory.episode_id == event.episode_id, Memory.id == event.derived_memory_id),
|
|
20
|
+
Memory.status != "deleted",
|
|
21
|
+
)
|
|
22
|
+
)
|
|
23
|
+
)
|
|
24
|
+
for memory in memories:
|
|
25
|
+
_scrub_memory(session, memory, now)
|
|
26
|
+
if event.derivative_policy == "invalidate":
|
|
27
|
+
memory.status = "invalidated"
|
|
28
|
+
episode = session.get(Episode, event.episode_id) if event.episode_id is not None else None
|
|
29
|
+
if episode is not None and episode.deleted_at is None:
|
|
30
|
+
forget_episode_graph(session, episode)
|
|
31
|
+
episode.content = ""
|
|
32
|
+
episode.extra = {}
|
|
33
|
+
episode.enrichment_error = None
|
|
34
|
+
episode.deleted_at = now
|
|
35
|
+
event.content = ""
|
|
36
|
+
event.metadata_ = {}
|
|
37
|
+
event.deleted_at = now
|
|
38
|
+
session.query(CaptureCheckpoint).filter(
|
|
39
|
+
CaptureCheckpoint.session_id == event.session_id,
|
|
40
|
+
CaptureCheckpoint.through_sequence >= event.sequence,
|
|
41
|
+
CaptureCheckpoint.deleted_at.is_(None),
|
|
42
|
+
).update({CaptureCheckpoint.deleted_at: now}, synchronize_session=False)
|
|
43
|
+
|
|
44
|
+
|
|
45
|
+
def expire_capture_events(session: Session, *, now: datetime | None = None) -> int:
|
|
46
|
+
"""Idempotently expire capture records and provenance-linked derivatives."""
|
|
47
|
+
effective_now = now or utcnow()
|
|
48
|
+
events = list(session.scalars(select(CaptureEvent).where(CaptureEvent.deleted_at.is_(None))))
|
|
49
|
+
expired = 0
|
|
50
|
+
for event in events:
|
|
51
|
+
occurred_at = event.occurred_at
|
|
52
|
+
if occurred_at.tzinfo is None and effective_now.tzinfo is not None:
|
|
53
|
+
occurred_at = occurred_at.replace(tzinfo=effective_now.tzinfo)
|
|
54
|
+
if occurred_at + timedelta(days=event.retention_days) <= effective_now:
|
|
55
|
+
_expire_event(session, event, effective_now)
|
|
56
|
+
expired += 1
|
|
57
|
+
return expired
|
|
58
|
+
|
|
59
|
+
|
|
60
|
+
def delete_capture_for_episode(session: Session, episode_id, now: datetime) -> None: # type: ignore[no-untyped-def]
|
|
61
|
+
for event in session.scalars(
|
|
62
|
+
select(CaptureEvent).where(
|
|
63
|
+
CaptureEvent.episode_id == episode_id, CaptureEvent.deleted_at.is_(None)
|
|
64
|
+
)
|
|
65
|
+
):
|
|
66
|
+
event.content = ""
|
|
67
|
+
event.metadata_ = {}
|
|
68
|
+
event.deleted_at = now
|
|
69
|
+
session.query(CaptureCheckpoint).filter(
|
|
70
|
+
CaptureCheckpoint.episode_id == episode_id,
|
|
71
|
+
CaptureCheckpoint.deleted_at.is_(None),
|
|
72
|
+
).update({CaptureCheckpoint.deleted_at: now}, synchronize_session=False)
|