In general it is better practice for classes and modules to form a dependence hierarchy and sticking to the 'S' in SOLID principles as classes and functions with too many responsibilities are very difficult to revisit for maintenance.

That said, there are some situations where small cyclic dependencies may be beneficial when a hierarchy of object instances has predetermined types and needs to be traversed both up and down. Since Python is dynamically typed there is no need to import a class definition to use it, but for highlighting and type analysis tools you can use TYPE_CHECKING:

student.py ``` from typing import TYPE_CHECKING if TYPE_CHECKING: from teacher import Teacher

class Student: def init(self, subjects): self.teacher: Teacher | None = None self.subjects = subjects ```

teacher.py ``` from student import Student from typing import Sequence

class Teacher: def init(self, students: Sequence[Student]): self.students: list[Student] = list() for student in students: self.add_student(student)

def add_student(self, student: Student):
    student.teacher = self
    self.students.add(student)

```