Files
breakpilot-lehrer/agent-core/brain/knowledge_models.py
Benjamin Admin bd4b956e3c [split-required] Split final 43 files (500-668 LOC) to complete refactoring
klausur-service (11 files):
- cv_gutter_repair, ocr_pipeline_regression, upload_api
- ocr_pipeline_sessions, smart_spell, nru_worksheet_generator
- ocr_pipeline_overlays, mail/aggregator, zeugnis_api
- cv_syllable_detect, self_rag

backend-lehrer (17 files):
- classroom_engine/suggestions, generators/quiz_generator
- worksheets_api, llm_gateway/comparison, state_engine_api
- classroom/models (→ 4 submodules), services/file_processor
- alerts_agent/api/wizard+digests+routes, content_generators/pdf
- classroom/routes/sessions, llm_gateway/inference
- classroom_engine/analytics, auth/keycloak_auth
- alerts_agent/processing/rule_engine, ai_processor/print_versions

agent-core (5 files):
- brain/memory_store, brain/knowledge_graph, brain/context_manager
- orchestrator/supervisor, sessions/session_manager

admin-lehrer (5 components):
- GridOverlay, StepGridReview, DevOpsPipelineSidebar
- DataFlowDiagram, sbom/wizard/page

website (2 files):
- DependencyMap, lehrer/abitur-archiv

Other: nibis_ingestion, grid_detection_service, export-doclayout-onnx

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-25 09:41:42 +02:00

105 lines
3.4 KiB
Python

"""
Knowledge Graph Models for Breakpilot Agents
Entity and relationship data classes, plus type enumerations.
"""
from typing import Dict, Any
from dataclasses import dataclass, field
from datetime import datetime, timezone
from enum import Enum
class EntityType(Enum):
"""Types of entities in the knowledge graph"""
STUDENT = "student"
TEACHER = "teacher"
CLASS = "class"
SUBJECT = "subject"
ASSIGNMENT = "assignment"
EXAM = "exam"
TOPIC = "topic"
CONCEPT = "concept"
RESOURCE = "resource"
CUSTOM = "custom"
class RelationshipType(Enum):
"""Types of relationships between entities"""
BELONGS_TO = "belongs_to" # Student belongs to class
TEACHES = "teaches" # Teacher teaches subject
ASSIGNED_TO = "assigned_to" # Assignment assigned to student
COVERS = "covers" # Exam covers topic
REQUIRES = "requires" # Topic requires concept
RELATED_TO = "related_to" # General relationship
PARENT_OF = "parent_of" # Hierarchical relationship
CREATED_BY = "created_by" # Creator relationship
GRADED_BY = "graded_by" # Grading relationship
@dataclass
class Entity:
"""Represents an entity in the knowledge graph"""
id: str
entity_type: EntityType
name: str
properties: Dict[str, Any] = field(default_factory=dict)
created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
updated_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
def to_dict(self) -> Dict[str, Any]:
return {
"id": self.id,
"entity_type": self.entity_type.value,
"name": self.name,
"properties": self.properties,
"created_at": self.created_at.isoformat(),
"updated_at": self.updated_at.isoformat()
}
@classmethod
def from_dict(cls, data: Dict[str, Any]) -> "Entity":
return cls(
id=data["id"],
entity_type=EntityType(data["entity_type"]),
name=data["name"],
properties=data.get("properties", {}),
created_at=datetime.fromisoformat(data["created_at"]),
updated_at=datetime.fromisoformat(data["updated_at"])
)
@dataclass
class Relationship:
"""Represents a relationship between two entities"""
id: str
source_id: str
target_id: str
relationship_type: RelationshipType
properties: Dict[str, Any] = field(default_factory=dict)
weight: float = 1.0
created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
def to_dict(self) -> Dict[str, Any]:
return {
"id": self.id,
"source_id": self.source_id,
"target_id": self.target_id,
"relationship_type": self.relationship_type.value,
"properties": self.properties,
"weight": self.weight,
"created_at": self.created_at.isoformat()
}
@classmethod
def from_dict(cls, data: Dict[str, Any]) -> "Relationship":
return cls(
id=data["id"],
source_id=data["source_id"],
target_id=data["target_id"],
relationship_type=RelationshipType(data["relationship_type"]),
properties=data.get("properties", {}),
weight=data.get("weight", 1.0),
created_at=datetime.fromisoformat(data["created_at"])
)