Add files using upload-large-folder tool

env/kimodo/lib/python3.10/site-packages/SpatialTransform/__init__.py

@@ -0,0 +1,3 @@
+from .lib.transform import Transform
+from .lib.pose import Pose
+from .lib.euler import Euler

env/kimodo/lib/python3.10/site-packages/SpatialTransform/lib/euler.py

@@ -0,0 +1,117 @@
+import math
+import glm
+
+
+# https://en.wikipedia.org/wiki/Euler_angles
+
+
+class Euler:
+    """Static collection of conversions for euler angles.
+
+    Matrices are expected to be column major, like glm.
+    """
+
+    def getOrders() -> list[str]:
+        """List of possible rotation orders in 3D space."""
+        return list(['XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX'])
+
+    def toQuatFrom(radians: glm.vec3, order: str = 'ZXY', extrinsic: bool = True) -> glm.quat:
+        """Converts euler angles to quaternion.
+
+        Rotation order of eulers must be given as 'XYZ' in any order.
+
+        If extrinsic the rotation will be around the world axes, ignoring previous rotations."""
+        result = glm.quat()
+        radians = glm.vec3(radians)
+
+        order = order.upper()
+        if extrinsic:
+            order = reversed(order)
+        for axis in order:
+            if axis == 'X': result = glm.rotate(result, radians.x, (1, 0, 0)); continue
+            if axis == 'Y': result = glm.rotate(result, radians.y, (0, 1, 0)); continue
+            if axis == 'Z': result = glm.rotate(result, radians.z, (0, 0, 1)); continue
+
+        return result
+
+    def toMatFrom(radians: glm.vec3, order: str = 'ZXY', extrinsic: bool = True) -> glm.mat3:
+        """Converts euler angles to 3x3 rotation matrix.
+
+        Rotation order of eulers must be given as 'XYZ' in any order.
+
+        If extrinsic the rotation will be around the world axes, ignoring previous rotations."""
+        return glm.mat3_cast(Euler.toQuatFrom(radians, order, extrinsic))
+
+    def fromQuatTo(quat: glm.quat, order: str = 'ZXY', extrinsic: bool = True) -> glm.vec3:
+        """Converts a quaternion to intrinsic euler angles as radians.
+
+        Rotation order of eulers must be given as 'XYZ' in any order.
+
+        If extrinsic the rotation will be around the world axes, ignoring previous rotations."""
+        return Euler.fromMatTo(glm.mat3_cast(quat), order, extrinsic)
+
+    def fromMatTo(mat: glm.mat3, order: str = 'ZXY', extrinsic: bool = True) -> glm.vec3:
+        """Converts a 3x3 rotation matrix to intrinsic euler angles as radians.
+
+        Rotation order of eulers must be given as 'XYZ' in any order.
+
+        If extrinsic the rotation will be around the world axes, ignoring previous rotations."""
+        order = order.upper()
+        if extrinsic: order = order[::-1]
+
+        if order == 'XYZ': return fromMatToXYZ(mat)
+        if order == 'XZY': return fromMatToXZY(mat)
+        if order == 'YXZ': return fromMatToYXZ(mat)
+        if order == 'YZX': return fromMatToYZX(mat)
+        if order == 'ZXY': return fromMatToZXY(mat)
+        if order == 'ZYX': return fromMatToZYX(mat)
+
+        raise ValueError(f'given order "{order}" is invalid. Must be "XYZ" in any order')
+
+
+def fromMatToXZY(mat: glm.mat3) -> glm.vec3:
+    return glm.vec3(
+        math.atan2(mat[1, 2], mat[1, 1]),
+        math.atan2(mat[2, 0], mat[0, 0]),
+        math.atan2(-mat[1, 0], math.sqrt(max(0, 1 - mat[1, 0]**2))),
+    )
+
+
+def fromMatToXYZ(mat: glm.mat3) -> glm.vec3:
+    return glm.vec3(
+        math.atan2(-mat[2, 1], mat[2, 2]),
+        math.atan2(mat[2, 0], math.sqrt(max(0, 1 - mat[2, 0]**2))),
+        math.atan2(-mat[1, 0], mat[0, 0]),
+    )
+
+
+def fromMatToYXZ(mat: glm.mat3) -> glm.vec3:
+    return glm.vec3(
+        math.atan2(-mat[2, 1], math.sqrt(max(0, 1 - mat[2, 1]**2))),
+        math.atan2(mat[2, 0], mat[2, 2]),
+        math.atan2(mat[0, 1], mat[1, 1]),
+    )
+
+
+def fromMatToYZX(mat: glm.mat3) -> glm.vec3:
+    return glm.vec3(
+        math.atan2(-mat[2, 1], mat[1, 1]),
+        math.atan2(-mat[0, 2], mat[0, 0]),
+        math.atan2(mat[0, 1], math.sqrt(max(0, 1 - mat[0, 1]**2))),
+    )
+
+
+def fromMatToZYX(mat: glm.mat3) -> glm.vec3:
+    return glm.vec3(
+        math.atan2(mat[1, 2], mat[2, 2]),
+        math.atan2(-mat[0, 2], math.sqrt(max(0, 1 - mat[0, 2]**2))),
+        math.atan2(mat[0, 1], mat[0, 0]),
+    )
+
+
+def fromMatToZXY(mat: glm.mat3) -> glm.vec3:
+    return glm.vec3(
+        math.atan2(mat[1, 2], math.sqrt(max(0, 1 - mat[1, 2]**2))),
+        math.atan2(-mat[0, 2], mat[2, 2]),
+        math.atan2(-mat[1, 0], mat[1, 1]),
+    )

env/kimodo/lib/python3.10/site-packages/SpatialTransform/lib/pose.py

@@ -0,0 +1,132 @@
+import glm
+from .euler import Euler
+
+
+class Pose:
+    """Spatial definition of an linear space with position, rotation and scale.
+    - ONLY provides properties and methods for local space.
+    - There is no parent child relation between poses
+    - Space is defined as right handed where -> Y+ is up, and X+ is right and Z- is forward.
+    - Positive rotations are counter clockwise."""
+
+    @property
+    def Space(self) -> glm.mat4:
+        """Transform space with properties."""
+        if self.__isOutdated:
+            self._Space = glm.translate(self.Position)
+            self._Space = glm.scale(self._Space, self.Scale)
+            self._Space = self._Space * glm.mat4_cast(self.Rotation)
+            self.__isOutdated = False
+        return glm.mat4(self._Space)
+
+    @property
+    def SpaceInverse(self) -> glm.mat4:
+        """Inverted transform space."""
+        return glm.inverse(self.Space)
+
+    @property
+    def Position(self) -> glm.vec3:
+        """Position of the space."""
+        return glm.vec3(self._Position)
+
+    @Position.setter
+    def Position(self, value: glm.vec3) -> None:
+        self._Position = glm.vec3(value)
+        self.__isOutdated = True
+
+    @property
+    def Rotation(self) -> glm.quat:
+        """Rotation of the space."""
+        return glm.quat(self._Rotation)
+
+    @Rotation.setter
+    def Rotation(self, value: glm.quat) -> None:
+        self._Rotation = glm.quat(value)
+        self.__isOutdated = True
+
+    @property
+    def Scale(self) -> glm.vec3:
+        """Scale of the space."""
+        return glm.vec3(self._Scale)
+
+    @Scale.setter
+    def Scale(self, value: glm.vec3) -> None:
+        self._Scale = glm.vec3(value)
+        self.__isOutdated = True
+
+    @property
+    def Forward(self) -> glm.vec3:
+        """Current alignment of the Z-axis."""
+        return self.Rotation * (0, 0, -1)
+
+    @property
+    def Right(self) -> glm.vec3:
+        """Current alignment of the X-axis."""
+        return self.Rotation * (1, 0, 0)
+
+    @property
+    def Up(self) -> glm.vec3:
+        """Current alignment of the Y-axis."""
+        return self.Rotation * (0, 1, 0)
+
+    def __init__(self, position: glm.vec3 = None, rotation: glm.quat = None, scale: glm.vec3 = None) -> None:
+        """Creates a new pose."""
+
+        self._Space = glm.mat4(1)
+        self._Position = glm.vec3() if position is None else glm.vec3(position)
+        self._Rotation = glm.quat() if rotation is None else glm.quat(rotation)
+        self._Scale = glm.vec3(1) if scale is None else glm.vec3(scale)
+        self.__isOutdated = True
+
+    def __repr__(self) -> str:
+        return (f"Pos: {self.Position}, Rot: {self.Rotation}, Scale: {self.Scale}")
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+    def reset(self) -> "Pose":
+        self.Position = glm.vec3(0)
+        self.Rotation = glm.quat()
+        self.Scale = glm.vec3(1)
+
+    def getEuler(self, order: str = 'ZXY', extrinsic: bool = True) -> glm.vec3:
+        """Returns the current Rotation as euler angles in the given order.
+        - If extrinsic the rotation will be around the world axes, ignoring previous rotations."""
+        return glm.degrees(Euler.fromQuatTo(self.Rotation, order, extrinsic))
+
+    def setEuler(self, degrees: glm.vec3, order: str = 'ZXY', extrinsic: bool = True) -> "Pose":
+        """Converts the given euler anlges to quaternion and sets the rotation property.
+        - If extrinsic the rotation will be around the world axes, ignoring previous rotations.
+
+        Returns itself."""
+        self.Rotation = Euler.toQuatFrom(glm.radians(degrees), order, extrinsic)
+        return self
+
+    def addEuler(self, degrees: glm.vec3, order: str = 'ZXY', extrinsic: bool = True, last: bool = True) -> "Pose":
+        """Adds an euler rotation to the current rotation.
+        - If extrinsic the rotation will be around the world axes, ignoring previous rotations.
+        - If last is True -> The rotation is added after the current rotation.
+
+        Returns itself."""
+        if last:
+            self.Rotation = Euler.toQuatFrom(glm.radians(degrees), order, extrinsic) * self.Rotation
+        else:
+            self.Rotation = self.Rotation * Euler.toQuatFrom(glm.radians(degrees), order, extrinsic)
+
+        return self
+
+    def lookAt(self, direction: glm.vec3, up: glm.vec3 = glm.vec3(0, 1, 0)) -> "Pose":
+        """Sets Rotation so the Z- axis aligns with the given direction.
+        - Direction is considered as local space.
+
+        Returns itself."""
+        direction = glm.normalize(direction)
+        dirDot = abs(glm.dot(direction, (0, 1, 0)))
+        upAxis = up if dirDot < 0.999 else glm.vec3(1, 0, 0)
+        self.Rotation = glm.quatLookAtRH(direction, upAxis)
+
+        return self
+
+    def duplicate(self) -> "Pose":
+        """Returns a duplicate of this pose."""
+        return Pose(self.Position, self.Rotation, self.Scale)

env/kimodo/lib/python3.10/site-packages/SpatialTransform/lib/transform.py

@@ -0,0 +1,403 @@
+import re
+import glm
+import random
+import string
+from .pose import Pose
+
+
+class Transform(Pose):
+    """Spatial definition of an linear space with position, rotation and scale.
+    - Based on 'Pose' class, extended with parent child relation ship propertis and methods.
+    - Space is defined as right handed where -> Y+ is up, and X+ is right and Z- is forward.
+    - Positive rotations are counter clockwise."""
+
+    @property
+    def Name(self) -> str:
+        """Name of the transform."""
+        return self._Name
+
+    @Name.setter
+    def Name(self, value: str) -> None:
+        self._Name = value
+
+    @property
+    def SpaceWorld(self) -> glm.mat4:
+        """Transform space with respect to the parent."""
+        return (self.Parent.SpaceWorld if self.Parent else glm.mat4()) * self.Space
+
+    @property
+    def SpaceWorldInverse(self) -> glm.mat4:
+        """Inverted transform space with respect to the parent."""
+        return glm.inverse(self.SpaceWorld)
+
+    @property
+    def PositionWorld(self) -> glm.vec3:
+        """World position of the space."""
+        parentSpace = self.Parent.SpaceWorld if self.Parent else glm.mat4()
+        return parentSpace * self.Position
+
+    @PositionWorld.setter
+    def PositionWorld(self, value: glm.vec3) -> None:
+        parentSpaceInverse = self.Parent.SpaceWorldInverse if self.Parent else glm.mat4()
+        self._Position = parentSpaceInverse * value
+
+    @property
+    def RotationWorld(self) -> glm.quat:
+        """World rotation of the space."""
+        parentSpace = self.Parent.RotationWorld if self.Parent else glm.quat()
+        return parentSpace * self.Rotation
+
+    @RotationWorld.setter
+    def RotationWorld(self, value: glm.quat) -> None:
+        parentSpaceInverse = self.Parent.RotationWorldInverse if self.Parent else glm.quat()
+        self._Rotation = parentSpaceInverse * value
+
+    @property
+    def RotationWorldInverse(self) -> glm.quat:
+        """Inverse world rotation of the space."""
+        return glm.inverse(self.RotationWorld)
+
+    @property
+    def ScaleWorld(self) -> glm.vec3:
+        """World scale of the space."""
+        parentSpace = self.Parent.ScaleWorld if self.Parent else glm.vec3(1)
+        return parentSpace * self.Scale
+
+    @ScaleWorld.setter
+    def ScaleWorld(self, value: glm.vec3) -> None:
+        parentSpaceInverse = self.Parent.ScaleWorldInverse if self.Parent else glm.vec3(1)
+        self._Scale = parentSpaceInverse * value
+
+    @property
+    def ScaleWorldInverse(self) -> glm.vec3:
+        """Inverse world scale of the space."""
+        return (1.0 / self.ScaleWorld)
+
+    @property
+    def ForwardWorld(self) -> glm.vec3:
+        """Current rotation of the Z-axis in world space."""
+        return (self.RotationWorld * (0, 0, -1, 0)).xyz
+
+    @property
+    def RightWorld(self) -> glm.vec3:
+        """Current rotation of the X-axis in world space."""
+        return (self.RotationWorld * (1, 0, 0, 0)).xyz
+
+    @property
+    def UpWorld(self) -> glm.vec3:
+        """Current rotation of the Y-axis in world space."""
+        return (self.RotationWorld * (0, 1, 0, 0)).xyz
+
+    @property
+    def Parent(self) -> "Transform":
+        """Transform where this one aligns in repsect to it."""
+        return self._Parent
+
+    @property
+    def Children(self) -> list["Transform"]:
+        """Attachted transforms. This transform builds the parent space for those children."""
+        return self._Children
+
+    def __init__(self, name: str = None, position: glm.vec3 = None, rotation: glm.quat = None, scale: glm.vec3 = None) -> None:
+        """Creates a new transform. Parameters are considered as local space properties."""
+        super().__init__(position, rotation, scale)
+
+        self.Name = name if name is not None else ''.join(random.choice(string.ascii_letters) for _ in range(8))
+        self._Parent: "Transform" = None
+        self._Children: list["Transform"] = []
+
+    def __repr__(self) -> str:
+        return (f"{self.Name}")
+
+    def __str__(self) -> str:
+        return (f"Name: {self.Name}, Children: {len(self.Children)}, {super().__str__()}")
+
+    def reset(self, recursive: bool = False) -> "Transform":
+        """Resets the transform to pos: (0,0,0) scale: (1,1,1) and no rotation.
+
+        Returns itself."""
+        super().reset()
+
+        if recursive:
+            for child in self.Children:
+                child.reset(recursive=True)
+
+        return self
+
+    def pointToWorld(self, point: glm.vec3) -> glm.vec3:
+        """Transforms a given point in this  space to world space."""
+        return self.SpaceWorld * point
+
+    def pointToLocal(self, point: glm.vec3) -> glm.vec3:
+        """Transforms a given point in world space to this local space."""
+        return self.SpaceWorldInverse * point
+
+    def directionToWorld(self, direction: glm.vec3) -> glm.vec3:
+        """Transforms a given direction in this  space to world space."""
+        return self.RotationWorld * direction
+
+    def directionToLocal(self, direction: glm.vec3) -> glm.vec3:
+        """Transforms a given direction in world space to this local space."""
+        return self.RotationWorldInverse * direction
+
+    def lookAt(self, direction: glm.vec3, up: glm.vec3 = glm.vec3(0, 1, 0)) -> "Transform":
+        return super().lookAt(direction, up)
+
+    def lookAtWorld(self, direction: glm.vec3, up: glm.vec3 = glm.vec3(0, 1, 0)) -> "Transform":
+        """Sets Rotation so the Z- axis aligns with the given direction.
+        - Direction is considered as world space.
+
+        Returns itself."""
+        parentWorldRotationInverse = (self.Parent.RotationWorldInverse if self.Parent else glm.mat4())
+        direction = parentWorldRotationInverse * direction
+
+        return super().lookAt(direction, up)
+
+    def setEuler(self, degrees: glm.vec3, order: str = 'ZXY', extrinsic: bool = True) -> "Transform":
+        return super().setEuler(degrees, order, extrinsic)
+
+    def attach(self, *nodes: "Transform", keep: list[str] = ['position', 'rotation', 'scale']) -> "Transform":
+        """Attaches the given transforms to this one as a child.
+        - If keep contains properties -> the property is modified to keep its spatial algiment in world space.
+        - If keep is None or empty -> Local space propteries do not change.
+        - If the transform is detatched first if it already has parent.
+        - Nothing will change if the node already has a relation to this transform.
+
+        Returns itself."""
+        for node in nodes:
+            # validate given joint
+            if node is None: raise ValueError('Given joint value is None')
+            if node is self: raise ValueError(f'Joint "{self.Name}" cannot be parent of itself')
+            if node in self.Children: continue
+
+            # detach
+            if node._Parent is not None:
+                node._Parent.detach(node, keep=keep)
+
+            # attatch
+            self.Children.append(node)
+            node._Parent = self
+
+            # correct world space alignment
+            if keep is not None:
+                if 'position' in keep: node.Position = self.SpaceWorldInverse * node.Position
+                if 'rotation' in keep: node.Rotation = self.RotationWorldInverse * node.Rotation
+                if 'scale' in keep: node.Scale = self.ScaleWorldInverse * node.Scale
+        return self
+
+    def detach(self, *nodes: "Transform", keep: list[str] = ['position', 'rotation', 'scale']) -> "Transform":
+        """Detachs the given child transform.
+        - If keep contains properties -> the property is modified to keep its spatial algiment in world space.
+        - If keep is None or empty -> Local space propteries do not change.
+        - Nothing will change if the node has no relation to this transform.
+
+        Returns itself."""
+        for node in nodes:
+            # validate given joint
+            if node is None: raise ValueError('Given joint value is None')
+            if node is self: raise ValueError(f'Joint "{self.Name}" cannot be detachd from itself')
+            if node.Parent is self and node not in self.Children: raise ValueError(f'Joint "{node.Name}" has "{self.Name}" as parent, bust does not exist in the children list. Avoid manual child parent modifications')
+            if node.Parent is None or node.Parent != self: continue
+
+            # correct world space alignment
+            if keep is not None:
+                if 'position' in keep: node.Position = self.SpaceWorld * node.Position
+                if 'rotation' in keep: node.Rotation = self.RotationWorld * node.Rotation
+                if 'scale' in keep: node.Scale = self.ScaleWorld * node.Scale
+
+            # detach
+            self.Children.remove(node)
+            node._Parent = None
+        return self
+
+    def clearParent(self, keep: list[str] = ['position', 'rotation', 'scale']) -> "Transform":
+        """Detaches/detachs itself from the parent.
+        - If keep contains properties -> the property is modified to keep its spatial algiment in world space.
+        - If keep is None or empty -> Local space propteries do not change.
+
+        Returns itself."""
+        if self.Parent is not None:
+            self.Parent.detach(self, keep=keep)
+        return self
+
+    def clearChildren(self, keep: list[str] = ['position', 'rotation', 'scale']) -> "Transform":
+        """Detachs all children of this transform.
+        - If keep contains properties -> the property is modified to keep its spatial algiment in world space.
+        - If keep is None or empty -> Local space propteries do not change.
+
+        Returns itself."""
+        if (len(self.Children) > 0):
+            self.detach(*self.Children, keep=keep)
+        return self
+
+    def _applyPositionGetChanges(self, position: glm.vec3 = None) -> tuple[glm.vec3, glm.vec3]:
+        change = -self.Position if position is None else position
+        changeInverse = glm.inverse(self.Rotation) * ((1.0 / self.Scale) * -change)
+        return (change, changeInverse)
+
+    def _applyPositionChange(self, change: glm.vec3):
+        self.Position = self.Position + change
+
+    def _applyPositionChangeInverse(self, changeInverse: glm.vec3):
+        self.Position = self.Position + changeInverse
+
+    def applyPosition(self, position: glm.vec3 = None, recursive: bool = False) -> "Transform":
+        """Changes the position of this transform and updates its children to keep them spatial unchanged.
+        - If position is None -> the transform resets its position to (0, 0, 0).
+        - If position IS set -> the given position is added to the current position.
+
+        Returns itself."""
+        change, changeInverse = self._applyPositionGetChanges(position)
+
+        self._applyPositionChange(change)
+
+        for child in self.Children:
+            child._applyPositionChangeInverse(changeInverse)
+
+            if recursive:
+                child.applyPosition(position=position, recursive=True)
+
+        return self
+
+    def _applyRotationGetChanges(self, rotation: glm.quat = None) -> tuple[glm.quat, glm.quat]:
+        change = glm.inverse(self.Rotation) if rotation is None else rotation
+        changeInverse = glm.inverse(change)
+        return (change, changeInverse)
+
+    def _applyRotationChange(self, change: glm.quat):
+        self.Rotation = self.Rotation * change
+
+    def _applyRotationChangeInverse(self, changeInverse: glm.quat, bake: bool = False):
+        self.Position = changeInverse * self.Position
+        if not bake:
+            self.Rotation = changeInverse * self.Rotation
+
+    def applyRotation(self, rotation: glm.quat = None, recursive: bool = False, bake: bool = False) -> "Transform":
+        """Changes the rotation of this transform and updates its children to keep them spatial unchanged.
+        - If rotation is None -> the transform resets its rotation to (1, 0, 0, 0).
+        - If rotation IS set -> the given rotation is added to the current rotation.
+        - If bake Is True -> The rotation correction is NOT passed to the children, only positions will be modified.
+
+        Returns itself."""
+        change, changeInverse = self._applyRotationGetChanges(rotation)
+
+        self._applyRotationChange(change)
+
+        for child in self.Children:
+            child._applyRotationChangeInverse(changeInverse, bake=bake)
+
+            if recursive:
+                child.applyRotation(rotation=rotation, recursive=True, bake=bake)
+
+        return self
+
+    def _applyScaleGetChanges(self, scale: glm.vec3 = None) -> tuple[glm.vec3, glm.vec3]:
+        change = (1.0 / self.Scale) if scale is None else scale
+        changeInverse = (1.0 / change)
+        return (change, changeInverse)
+
+    def _applyScaleChange(self, change: glm.vec3):
+        self.Scale = self.Scale * change
+
+    def _applyScaleChangeInverse(self, changeInverse: glm.vec3, bake: bool = False):
+        self.Position = changeInverse * self.Position
+        if not bake:
+            self.Scale = changeInverse * self.Scale
+
+    def applyScale(self, scale: glm.vec3 = None, recursive: bool = False, bake: bool = False) -> "Transform":
+        """Changes the scale of the transform and updates its children to keep them spatial unchanged.
+        - If scale is NOT set -> The transform resets its scale to (1, 1, 1).
+        - If scale IS set -> The given scale is added to the current scale.
+        - If bake Is True -> The scale correction is NOT passed to the children, only positions will be modified.
+
+        Returns itself."""
+        change, changeInverse = self._applyScaleGetChanges(scale)
+
+        self._applyScaleChange(change)
+
+        for child in self.Children:
+            child._applyScaleChangeInverse(changeInverse, bake=bake)
+
+            if recursive:
+                child.applyScale(scale=scale, recursive=True, bake=bake)
+
+        return self
+
+    def layout(self, index: int = 0, depth: int = 0) -> list[tuple["Transform", int, int]]:
+        """Returns the hierarchy, inclunding this transform, in order of 'depth first' with their index and depth.
+        - Order of the tuple -> [transform, index, depth]"""
+        result = [[self, index, depth]]
+        for child in self.Children:
+            result.extend(child.layout(result[-1][1] + 1, depth + 1))
+        return result
+
+    def printTree(self, markerStr="+- ", levelMarkers=[]) -> None:
+        # src: https://simonhessner.de/python-3-recursively-print-structured-tree-including-hierarchy-markers-using-depth-first-search/
+        """
+        Recursive function that prints the hierarchical structure of a tree including markers that indicate parent-child relationships between nodes.
+
+        Parameters:
+        - root: Node instance, possibly containing children Nodes
+        - markerStr: String to print in front of each node  ("+- " by default)
+        - levelMarkers: Internally used by recursion to indicate where to
+                        print markers and connections (see explanations below)
+        """
+
+        def mapper(draw): return connectionStr if draw else emptyStr
+        emptyStr = " " * len(markerStr)
+        connectionStr = "|" + emptyStr[:-1]
+        level = len(levelMarkers)   # recursion level
+        markers = "".join(map(mapper, levelMarkers[:-1]))
+        markers += markerStr if level > 0 else ""
+        print(f"{markers}{self.Name}")
+
+        for i, child in enumerate(self.Children):
+            isLast = i == len(self.Children) - 1
+            child.printTree(markerStr, [*levelMarkers, not isLast])
+
+    def filter(self, pattern: str, isEqual: bool = False, caseSensitive: bool = False) -> list["Transform"]:
+        """Tries to find transforms that matches the pattern in their name name.
+        - If isEqual is true, the name has to be equal to the pattern. Otherwise the pattern must only appear anywhere in the name."""
+        result = []
+
+        selfname = self.Name if caseSensitive else self.Name.lower()
+        if not caseSensitive: pattern = pattern.lower()
+
+        if (isEqual and pattern == selfname) or (not isEqual and pattern in selfname):
+            result.append(self)
+        for child in self.Children:
+            result.extend(child.filter(pattern, isEqual, caseSensitive))
+
+        return result
+
+    def filterRegex(self, pattern: str) -> list["Transform"]:
+        """Tries to find transforms that matches the pattern in their name name."""
+        result = []
+
+        if re.match(pattern, self.Name) is not None:
+            result.append(self)
+        for child in self.Children:
+            result.extend(child.filterRegex(pattern))
+
+        return result
+
+    def duplicate(self, recursive: bool = False) -> "Transform":
+        """Returns a duplicate of this transform.
+        - If recursive is True -> All child transfroms are duplicated too, into this duplicate."""
+
+        newChildren = [child.duplicate(recursive=True) for child in self.Children] if recursive else []
+        newDuplicate = Transform(self.Name, self.Position, self.Rotation, self.Scale)
+        return newDuplicate.attach(*newChildren, keep=None)
+
+    def toPose(self, worldSpace: bool = False) -> Pose:
+        """Returns this transform as new pose object.
+        - If worldSpace is True -> The world spcae properties are copied into the pose."""
+        if worldSpace:
+            return Pose(self.PositionWorld, rotation=self.RotationWorld, scale=self.ScaleWorld)
+        else:
+            return Pose(self.Position, rotation=self.Rotation, scale=self.Scale)
+
+    def fromPose(pose: Pose, name: str = None) -> "Transform":
+        """Returns this pose as new transform.
+        - If name is set -> The name will be set for the new transform."""
+        return Transform(name=name, position=pose.Position, rotation=pose.Rotation, scale=pose.Scale)

env/kimodo/lib/python3.10/site-packages/SpatialTransform/tests/test_euler.py

@@ -0,0 +1,120 @@
+import glm
+import unittest
+import math
+from .utils import *
+from SpatialTransform import Euler
+
+class Conversions(unittest.TestCase):
+    def test_toQuatFrom(self):
+        for _ in range(randomSamples):
+            r = randomRotation()
+            e = glm.eulerAngles(r)
+            angle = glm.angle(Euler.toQuatFrom(e, order='XYZ', extrinsic=True) * glm.inverse(r))
+            self.assertFalse(0.01 < angle < (glm.two_pi()-0.01))
+
+    def test_fromMatTo(self):
+        for _ in range(randomSamples):
+            r = randomRotation()
+            e = glm.eulerAngles(r)
+            m = glm.mat3_cast(r)
+            self.assertGreater(0.01, glm.distance(e, Euler.fromMatTo(m, order='XYZ', extrinsic=True)))
+
+    def test_toMatFrom(self):
+        """Test toMatFrom method."""
+        for _ in range(randomSamples):
+            euler = glm.vec3(
+                random.uniform(-math.pi, math.pi),
+                random.uniform(-math.pi, math.pi),
+                random.uniform(-math.pi, math.pi)
+            )
+
+            # Test different orders
+            orders = ['XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX']
+            for order in orders:
+                for extrinsic in [True, False]:
+                    mat = Euler.toMatFrom(euler, order=order, extrinsic=extrinsic)
+                    self.assertIsInstance(mat, glm.mat3)
+
+                    # Verify it's a proper rotation matrix (determinant should be 1)
+                    det = glm.determinant(mat)
+                    self.assertGreater(0.01, abs(det - 1.0))
+
+    def test_fromQuatTo(self):
+        """Test fromQuatTo method."""
+        for _ in range(randomSamples):
+            rotation = randomRotation()
+
+            # Test different orders
+            orders = ['XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX']
+            for order in orders:
+                for extrinsic in [True, False]:
+                    euler = Euler.fromQuatTo(rotation, order=order, extrinsic=extrinsic)
+                    self.assertIsInstance(euler, glm.vec3)
+
+                    # Round trip test
+                    recovered_quat = Euler.toQuatFrom(euler, order=order, extrinsic=extrinsic)
+                    angle_diff = glm.angle(rotation * glm.inverse(recovered_quat))
+                    self.assertFalse(0.01 < angle_diff < (glm.two_pi()-0.01))
+
+    def test_all_rotation_orders(self):
+        """Test all supported rotation orders."""
+        orders = ['XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX']
+
+        for order in orders:
+            for extrinsic in [True, False]:
+                euler = glm.vec3(0.5, 1.0, 1.5)  # Test angles in radians
+
+                # Test conversion chain: euler -> quat -> mat -> euler
+                quat = Euler.toQuatFrom(euler, order=order, extrinsic=extrinsic)
+                mat = Euler.toMatFrom(euler, order=order, extrinsic=extrinsic)
+
+                # Verify quat and mat represent same rotation
+                mat_from_quat = glm.mat3_cast(quat)
+                for i in range(3):
+                    for j in range(3):
+                        self.assertGreater(0.01, abs(mat[i][j] - mat_from_quat[i][j]))
+
+    def test_round_trip_conversions(self):
+        """Test round trip conversions between different representations."""
+        for _ in range(100):  # Fewer samples for complex test
+            original_euler = glm.vec3(
+                random.uniform(-math.pi/2, math.pi/2),  # Avoid gimbal lock
+                random.uniform(-math.pi/2, math.pi/2),
+                random.uniform(-math.pi/2, math.pi/2)
+            )
+
+            order = 'XYZ'
+            extrinsic = True
+
+            # euler -> quat -> euler
+            quat = Euler.toQuatFrom(original_euler, order=order, extrinsic=extrinsic)
+            recovered_euler = Euler.fromQuatTo(quat, order=order, extrinsic=extrinsic)
+            self.assertGreater(0.1, glm.distance(original_euler, recovered_euler))
+
+            # euler -> mat -> euler
+            mat = Euler.toMatFrom(original_euler, order=order, extrinsic=extrinsic)
+            recovered_euler_mat = Euler.fromMatTo(mat, order=order, extrinsic=extrinsic)
+            self.assertGreater(0.1, glm.distance(original_euler, recovered_euler_mat))
+
+
+class EulerUtilities(unittest.TestCase):
+    def test_getOrders(self):
+        """Test getOrders static method."""
+        orders = Euler.getOrders()
+        expected_orders = ['XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX']
+
+        self.assertEqual(len(expected_orders), len(orders))
+        for order in expected_orders:
+            self.assertIn(order, orders)
+
+    def test_invalid_order(self):
+        """Test behavior with invalid rotation order."""
+        euler = glm.vec3(0.1, 0.2, 0.3)
+
+        # This should raise an error for invalid order
+        with self.assertRaises(ValueError):
+            Euler.fromMatTo(glm.mat3(), order='INVALID', extrinsic=True)
+
+
+if __name__ == '__main__':
+    unittest.main()

env/kimodo/lib/python3.10/site-packages/SpatialTransform/tests/test_hierarchy.py

@@ -0,0 +1,188 @@
+import unittest
+from .utils import *
+from SpatialTransform import Transform
+
+class AddRemove(unittest.TestCase):
+    def test_attatch(self):
+        root = Transform()
+        child1 = Transform()
+        child2= Transform()
+        child3 = Transform()
+        child4= Transform()
+
+        root.attach(child1)
+        self.assertEqual(root, child1.Parent)
+        self.assertEqual(1, len(root.Children))
+
+        root.attach(child2)
+        self.assertEqual(root, child2.Parent)
+        self.assertEqual(2, len(root.Children))
+
+        root.attach(child3, child4)
+        self.assertEqual(root, child3.Parent)
+        self.assertEqual(root, child4.Parent)
+        self.assertEqual(4, len(root.Children))
+
+        root.attach(child1)
+
+
+    def test_attatchKeepProperties(self):
+        for _ in range(randomSamples):
+            root = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            child1 = Transform()
+            child2 = Transform()
+
+            for _ in range(2):
+                root.attach(child1, keep=None)
+                self.assertGreater(deltaPosition, glm.distance2(root.SpaceWorld * glm.vec3(0), child1.PositionWorld))
+                self.assertGreater(deltaRotation, glm.angle(root.RotationWorld * glm.inverse(child1.RotationWorld)))
+                self.assertGreater(deltaScale, glm.distance2(root.ScaleWorld, child1.ScaleWorld))
+
+            for _ in range(2):
+                root.attach(child2, keep=['position', 'rotation', 'scale'])
+                self.assertGreater(deltaPosition, glm.distance2(glm.vec3(0), child2.PositionWorld))
+                self.assertGreater(deltaRotation, glm.angle(child2.RotationWorld))
+                self.assertGreater(deltaScale, glm.distance2(glm.vec3(1), child2.ScaleWorld))
+
+    def test_detatch(self):
+        root = Transform()
+        child1 = Transform()
+        child2 = Transform()
+
+        root.attach(child1, child2)
+
+        root.detach(child1)
+        self.assertEqual(None, child1.Parent)
+        self.assertEqual(1, len(root.Children))
+
+        root.detach(child2)
+        self.assertEqual(None, child2.Parent)
+        self.assertEqual(0, len(root.Children))
+
+        otherRoot = Transform().attach(child1)
+        root.clearChildren().attach(child2)
+        root.detach(child1, child2)
+        self.assertEqual(1, len(otherRoot.Children))
+        self.assertEqual(0, len(root.Children))
+        self.assertEqual(otherRoot, child1.Parent)
+        self.assertEqual(None, child2.Parent)
+
+    def test_detatch_Exceptions(self):
+        child = Transform()
+        root = Transform().attach(child)
+        root.Children.remove(child)
+
+        self.assertRaises(ValueError, root.detach, None)
+        self.assertRaises(ValueError, root.detach, root)
+        self.assertRaises(ValueError, root.detach, child)
+
+    def test_attach_exceptions(self):
+        """Test attach method exception handling."""
+        root = Transform()
+
+        # Test attaching None
+        with self.assertRaises(ValueError):
+            root.attach(None)
+
+        # Test attaching self
+        with self.assertRaises(ValueError):
+            root.attach(root)
+
+    def test_attach_already_attached(self):
+        """Test attaching already attached child (should not duplicate)."""
+        root = Transform()
+        child = Transform()
+
+        root.attach(child)
+        initial_count = len(root.Children)
+
+        # Attach same child again - should not duplicate
+        root.attach(child)
+        self.assertEqual(initial_count, len(root.Children))
+
+    def test_detach_unrelated_transform(self):
+        """Test detaching transform that isn't a child."""
+        root = Transform()
+        other_root = Transform()
+        child = Transform()
+
+        other_root.attach(child)
+
+        # Should not raise error, just do nothing
+        initial_count = len(root.Children)
+        root.detach(child)
+        self.assertEqual(initial_count, len(root.Children))
+
+    def test_clear_operations_on_empty(self):
+        """Test clear operations on transforms with no children/parent."""
+        transform = Transform()
+
+        # Should not raise errors
+        transform.clearChildren()
+        transform.clearParent()
+
+        self.assertEqual(0, len(transform.Children))
+        self.assertIsNone(transform.Parent)
+
+    def test_detatchKeepProperties(self):
+        for _ in range(randomSamples):
+            root = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            child1 = Transform()
+            child2 = Transform()
+            root.attach(child1, child2, keep=None)
+
+            for _ in range(2):
+                root.detach(child1, keep=None)
+                self.assertGreater(deltaPosition, glm.distance2(glm.vec3(0), child1.PositionWorld))
+                self.assertGreater(deltaRotation, glm.angle(child1.RotationWorld))
+                self.assertGreater(deltaScale, glm.distance2(glm.vec3(1), child1.ScaleWorld))
+
+            for _ in range(2):
+                root.detach(child2, keep=['position', 'rotation', 'scale'])
+                self.assertGreater(deltaPosition, glm.distance2(root.SpaceWorld * glm.vec3(0), child2.PositionWorld))
+                self.assertGreater(deltaRotation, glm.angle(root.RotationWorld * glm.inverse(child2.RotationWorld)))
+                self.assertGreater(deltaScale, glm.distance2(root.ScaleWorld, child2.ScaleWorld))
+
+    def test_clearChildren(self):
+        root = Transform()
+        child1 = Transform()
+        child2 = Transform()
+
+        root.attach(child1)
+        root.clearChildren()
+        self.assertEqual(None, child1.Parent)
+        self.assertEqual(0, len(root.Children))
+
+        root.attach(child1, child2)
+        root.clearChildren()
+        self.assertEqual(None, child1.Parent)
+        self.assertEqual(None, child2.Parent)
+        self.assertEqual(0, len(root.Children))
+
+        root.clearChildren()
+        self.assertEqual(None, child1.Parent)
+        self.assertEqual(None, child2.Parent)
+        self.assertEqual(0, len(root.Children))
+
+    def test_clearParent(self):
+        root = Transform()
+        child1 = Transform()
+        child2 = Transform()
+
+        root.attach(child1, child2)
+        child1.clearParent()
+        self.assertEqual(None, child1.Parent)
+        self.assertEqual(1, len(root.Children))
+
+        child2.clearParent()
+        self.assertEqual(None, child1.Parent)
+        self.assertEqual(None, child2.Parent)
+        self.assertEqual(0, len(root.Children))
+
+        child2.clearParent()
+        self.assertEqual(None, child1.Parent)
+        self.assertEqual(None, child2.Parent)
+        self.assertEqual(0, len(root.Children))
+
+if __name__ == '__main__':
+    unittest.main()

env/kimodo/lib/python3.10/site-packages/SpatialTransform/tests/test_methods.py

@@ -0,0 +1,166 @@
+import glm
+import unittest
+from .utils import *
+from SpatialTransform import Transform, Euler
+
+class Convertions(unittest.TestCase):
+    def test_pointToWorld(self):
+        for _ in range(randomSamples):
+            p = randomPosition() * 10
+            t = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            c = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            t.attach(c)
+            self.assertEqual(c.pointToWorld(p), (t.Space * c.Space) * p)
+
+    def test_pointToLocal(self):
+        for _ in range(randomSamples):
+            p = randomPosition() * 10
+            t = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            c = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            t.attach(c)
+            self.assertEqual(c.pointToLocal(p), glm.inverse(t.Space * c.Space) * p)
+
+    def test_directionToWorld(self):
+        for _ in range(randomSamples):
+            p = randomPosition()
+            t = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            c = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            t.attach(c)
+            self.assertEqual(c.directionToWorld(p), (t.Rotation * c.Rotation) * p)
+
+    def test_directionToLocal(self):
+        for _ in range(randomSamples):
+            p = randomPosition()
+            t = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            c = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            t.attach(c)
+            self.assertEqual(c.directionToLocal(p), glm.inverse((t.Rotation * c.Rotation)) * p)
+
+    def test_duplicate(self):
+        p = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+        c = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+        p.attach(c, keep=None)
+        copy = p.duplicate(recursive=True)
+
+        self.assertNotEqual(copy, p)
+        self.assertEqual(copy.Name, p.Name)
+        self.assertEqual(copy.Position, p.Position)
+        self.assertEqual(copy.Rotation, p.Rotation)
+        self.assertEqual(copy.Scale, p.Scale)
+        self.assertEqual(copy.Parent, p.Parent)
+        self.assertEqual(len(copy.Children), len(p.Children))
+
+        self.assertNotEqual(copy.Children[0], p.Children[0])
+        self.assertEqual(copy.Children[0].Name, p.Children[0].Name)
+        self.assertEqual(copy.Children[0].Position, p.Children[0].Position)
+        self.assertEqual(copy.Children[0].Rotation, p.Children[0].Rotation)
+        self.assertEqual(copy.Children[0].Scale, p.Children[0].Scale)
+        self.assertEqual(copy.Children[0].Parent, copy)
+
+class Rotations(unittest.TestCase):
+    def test_setEuler(self):
+        t = Transform()
+        t.setEuler((+90, 0, 0), order='ZXY', extrinsic=True)
+        self.assertGreater(deltaPosition, glm.distance(glm.vec3(0,+1,0), t.Forward))
+        t.setEuler((-90, 0, 0), order='ZXY', extrinsic=True)
+        self.assertGreater(deltaPosition, glm.distance(glm.vec3(0,-1,0), t.Forward))
+
+        t.setEuler((0, +90, 0), order='ZXY', extrinsic=True)
+        self.assertGreater(deltaPosition, glm.distance(glm.vec3(-1,0,0), t.Forward))
+        t.setEuler((0, -90, 0), order='ZXY', extrinsic=True)
+        self.assertGreater(deltaPosition, glm.distance(glm.vec3(+1,0,0), t.Forward))
+
+        t.setEuler((0, 0, -90), order='ZXY', extrinsic=True)
+        self.assertGreater(deltaPosition, glm.distance(glm.vec3(0,0,-1), t.Forward))
+        t.setEuler((0, 0, +90), order='ZXY', extrinsic=True)
+        self.assertGreater(deltaPosition, glm.distance(glm.vec3(0,0,-1), t.Forward))
+
+        for _ in range(randomSamples):
+            r = randomRotation()
+            e = glm.degrees(glm.eulerAngles(r))
+            t.setEuler(e, order='XYZ', extrinsic=True)
+            angle = glm.angle(r * glm.inverse(t.Rotation))
+            self.assertFalse(0.01 < angle < (glm.two_pi()-0.01))
+
+    def test_lookAtWorld(self):
+        for _ in range(randomSamples):
+            t = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            c = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            t.attach(c)
+            d = randomDirection()
+            c.lookAtWorld(d)
+            self.assertGreater(deltaPosition, glm.distance(glm.normalize(d), c.ForwardWorld))
+            self.assertGreater(deltaPosition, glm.distance(t.RotationWorldInverse * glm.normalize(d), c.Forward))
+
+    def test_lookAt(self):
+        for _ in range(randomSamples):
+            t = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            c = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            t.attach(c)
+            d = randomDirection()
+            c.lookAt(d)
+            self.assertGreater(deltaPosition, glm.distance(glm.normalize(d), c.Forward))
+            self.assertGreater(deltaPosition, glm.distance(t.RotationWorld * glm.normalize(d), c.ForwardWorld))
+
+    def test_applyPosition(self):
+        for _ in range(randomSamples):
+            t = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            c = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            t.attach(c)
+            childWorld = c.PositionWorld
+            t.applyPosition()
+            self.assertGreater(deltaPosition, glm.distance2(glm.vec3(0), t.Position))
+            self.assertGreater(deltaPosition, glm.distance2(childWorld, c.PositionWorld))
+
+            addition = randomPosition()
+            t = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            c = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            t.attach(c)
+            parent = t.Position
+            childWorld = c.PositionWorld
+            t.applyPosition(addition)
+            self.assertGreater(deltaPosition, glm.distance2(parent + addition, t.Position))
+            self.assertGreater(deltaPosition, glm.distance2(childWorld, c.PositionWorld))
+
+    def test_applyRotation(self):
+        for _ in range(randomSamples):
+            t = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            c = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            t.attach(c)
+            childWorld = c.RotationWorld
+            t.applyRotation()
+            self.assertGreater(deltaRotation, glm.angle(t.Rotation))
+            self.assertGreater(deltaRotation, glm.angle(glm.inverse(c.RotationWorld) * childWorld))
+
+            addition = randomRotation()
+            t = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            c = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            t.attach(c)
+            parent = t.Rotation
+            childWorld = c.RotationWorld
+            t.applyRotation(addition)
+            self.assertGreater(deltaRotation, glm.angle((parent * addition) * glm.inverse(t.Rotation)))
+            self.assertGreater(deltaRotation, glm.angle(childWorld * glm.inverse(c.RotationWorld)))
+
+    def test_applyScale(self):
+        for _ in range(randomSamples):
+            t = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            c = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            t.attach(c)
+            childWorld = c.ScaleWorld
+            t.applyScale()
+            self.assertGreater(deltaPosition, glm.distance2(glm.vec3(1), t.Scale))
+            self.assertGreater(deltaPosition, glm.distance2(childWorld, c.ScaleWorld))
+
+            addition = randomScale()
+            t = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            c = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            t.attach(c)
+            parent = t.Scale
+            childWorld = c.ScaleWorld
+            t.applyScale(addition)
+            self.assertGreater(deltaPosition, glm.distance2(parent * addition, t.Scale))
+            self.assertGreater(deltaPosition, glm.distance2(childWorld, c.ScaleWorld))
+
+if __name__ == '__main__':
+    unittest.main()

env/kimodo/lib/python3.10/site-packages/SpatialTransform/tests/test_pose.py

@@ -0,0 +1,233 @@
+import glm
+import unittest
+from .utils import *
+from SpatialTransform import Pose, Euler
+
+
+class PoseProperties(unittest.TestCase):
+    def test_init_default(self):
+        """Test default initialization."""
+        p = Pose()
+        self.assertEqual(glm.vec3(0), p.Position)
+        self.assertEqual(glm.quat(), p.Rotation)
+        self.assertEqual(glm.vec3(1), p.Scale)
+        self.assertEqual(glm.mat4(), p.Space)
+        self.assertEqual(glm.vec3(0, 0, -1), p.Forward)
+        self.assertEqual(glm.vec3(1, 0, 0), p.Right)
+        self.assertEqual(glm.vec3(0, 1, 0), p.Up)
+
+    def test_init_with_parameters(self):
+        """Test initialization with custom parameters."""
+        for _ in range(randomSamples):
+            position = randomPosition()
+            rotation = randomRotation()
+            scale = randomScale()
+
+            p = Pose(position=position, rotation=rotation, scale=scale)
+            self.assertEqual(position, p.Position)
+            self.assertEqual(rotation, p.Rotation)
+            self.assertEqual(scale, p.Scale)
+
+    def test_space_matrix(self):
+        """Test the Space property calculation."""
+        for _ in range(randomSamples):
+            position = randomPosition()
+            rotation = randomRotation()
+            scale = randomScale()
+
+            p = Pose(position=position, rotation=rotation, scale=scale)
+            expected = (glm.translate(position) * glm.scale(scale)) * glm.mat4(rotation)
+            self.assertEqual(expected, p.Space)
+
+    def test_space_inverse(self):
+        """Test the SpaceInverse property."""
+        for _ in range(randomSamples):
+            p = Pose(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            expected = glm.inverse(p.Space)
+            self.assertEqual(expected, p.SpaceInverse)
+
+    def test_position_setter(self):
+        """Test Position property setter."""
+        p = Pose()
+        for _ in range(randomSamples):
+            position = randomPosition()
+            p.Position = position
+            self.assertEqual(position, p.Position)
+
+    def test_rotation_setter(self):
+        """Test Rotation property setter."""
+        p = Pose()
+        for _ in range(randomSamples):
+            rotation = randomRotation()
+            p.Rotation = rotation
+            self.assertEqual(rotation, p.Rotation)
+            # Test directional vectors
+            self.assertEqual(rotation * glm.vec3(0, 0, -1), p.Forward)
+            self.assertEqual(rotation * glm.vec3(1, 0, 0), p.Right)
+            self.assertEqual(rotation * glm.vec3(0, 1, 0), p.Up)
+
+    def test_scale_setter(self):
+        """Test Scale property setter."""
+        p = Pose()
+        for _ in range(randomSamples):
+            scale = randomScale()
+            p.Scale = scale
+            self.assertEqual(scale, p.Scale)
+
+    def test_directional_vectors(self):
+        """Test Forward, Right, Up properties."""
+        for _ in range(randomSamples):
+            rotation = randomRotation()
+            p = Pose(rotation=rotation)
+
+            expected_forward = rotation * glm.vec3(0, 0, -1)
+            expected_right = rotation * glm.vec3(1, 0, 0)
+            expected_up = rotation * glm.vec3(0, 1, 0)
+
+            self.assertGreater(deltaPosition, glm.distance(expected_forward, p.Forward))
+            self.assertGreater(deltaPosition, glm.distance(expected_right, p.Right))
+            self.assertGreater(deltaPosition, glm.distance(expected_up, p.Up))
+
+
+class PoseMethods(unittest.TestCase):
+    def test_reset(self):
+        """Test reset method."""
+        p = Pose(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+        p.reset()
+
+        self.assertEqual(glm.vec3(0), p.Position)
+        self.assertEqual(glm.quat(), p.Rotation)
+        self.assertEqual(glm.vec3(1), p.Scale)
+
+    def test_duplicate(self):
+        """Test duplicate method."""
+        for _ in range(randomSamples):
+            original = Pose(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            duplicate = original.duplicate()
+
+            # Should be different objects
+            self.assertNotEqual(id(original), id(duplicate))
+
+            # But same values
+            self.assertEqual(original.Position, duplicate.Position)
+            self.assertEqual(original.Rotation, duplicate.Rotation)
+            self.assertEqual(original.Scale, duplicate.Scale)
+
+    def test_look_at(self):
+        """Test lookAt method."""
+        p = Pose()
+
+        # Test basic directions
+        directions = [
+            glm.vec3(1, 0, 0),   # Right
+            glm.vec3(-1, 0, 0),  # Left
+            glm.vec3(0, 1, 0),   # Up
+            glm.vec3(0, -1, 0),  # Down
+            glm.vec3(0, 0, 1),   # Back
+            glm.vec3(0, 0, -1),  # Forward
+        ]
+
+        for direction in directions:
+            p.lookAt(direction)
+            self.assertGreater(deltaPosition, glm.distance(glm.normalize(direction), p.Forward))
+
+        # Test random directions
+        for _ in range(randomSamples):
+            direction = randomDirection()
+            p.lookAt(direction)
+            self.assertGreater(deltaPosition, glm.distance(glm.normalize(direction), p.Forward))
+
+    def test_look_at_with_up(self):
+        """Test lookAt method with custom up vector."""
+        p = Pose()
+        direction = glm.vec3(1, 0, 0)
+        up = glm.vec3(0, 0, 1)
+
+        p.lookAt(direction, up)
+        self.assertGreater(deltaPosition, glm.distance(glm.normalize(direction), p.Forward))
+
+    def test_get_euler(self):
+        """Test getEuler method."""
+        for _ in range(randomSamples):
+            rotation = randomRotation()
+            p = Pose(rotation=rotation)
+
+            # Test different orders
+            orders = ['XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX']
+            for order in orders:
+                for extrinsic in [True, False]:
+                    euler = p.getEuler(order=order, extrinsic=extrinsic)
+                    self.assertIsInstance(euler, glm.vec3)
+
+    def test_set_euler(self):
+        """Test setEuler method."""
+        p = Pose()
+
+        for _ in range(randomSamples):
+            euler_degrees = glm.vec3(
+                random.uniform(-180, 180),
+                random.uniform(-180, 180),
+                random.uniform(-180, 180)
+            )
+
+            result = p.setEuler(euler_degrees)
+            self.assertEqual(p, result)  # Should return self
+
+            # Verify rotation was set
+            self.assertNotEqual(glm.quat(), p.Rotation)
+
+    def test_add_euler(self):
+        """Test addEuler method."""
+        p = Pose(rotation=randomRotation())
+        original_rotation = p.Rotation
+
+        euler_degrees = glm.vec3(10, 20, 30)
+
+        # Test last=True
+        result = p.addEuler(euler_degrees, last=True)
+        self.assertEqual(p, result)  # Should return self
+        self.assertNotEqual(original_rotation, p.Rotation)
+
+        # Test last=False
+        p.Rotation = original_rotation
+        p.addEuler(euler_degrees, last=False)
+        self.assertNotEqual(original_rotation, p.Rotation)
+
+    def test_euler_round_trip(self):
+        """Test setEuler and getEuler round trip."""
+        p = Pose()
+
+        for _ in range(100):  # Use fewer samples for complex test
+            euler_degrees = glm.vec3(
+                random.uniform(-89, 89),  # Avoid gimbal lock
+                random.uniform(-89, 89),
+                random.uniform(-89, 89)
+            )
+
+            p.setEuler(euler_degrees, order='XYZ', extrinsic=True)
+            retrieved_euler = p.getEuler(order='XYZ', extrinsic=True)
+
+            # Allow for small numerical differences
+            self.assertGreater(1.0, glm.distance(euler_degrees, retrieved_euler))
+
+
+class PoseRepresentation(unittest.TestCase):
+    def test_repr(self):
+        """Test __repr__ method."""
+        p = Pose(position=glm.vec3(1, 2, 3), rotation=glm.quat(1, 0, 0, 0), scale=glm.vec3(2, 2, 2))
+        repr_str = repr(p)
+        self.assertIn("Pos:", repr_str)
+        self.assertIn("Rot:", repr_str)
+        self.assertIn("Scale:", repr_str)
+
+    def test_str(self):
+        """Test __str__ method."""
+        p = Pose(position=glm.vec3(1, 2, 3), rotation=glm.quat(1, 0, 0, 0), scale=glm.vec3(2, 2, 2))
+        str_repr = str(p)
+        self.assertIn("Pos:", str_repr)
+        self.assertIn("Rot:", str_repr)
+        self.assertIn("Scale:", str_repr)
+
+
+if __name__ == '__main__':
+    unittest.main()

env/kimodo/lib/python3.10/site-packages/SpatialTransform/tests/test_properties.py

@@ -0,0 +1,173 @@
+import glm
+import unittest
+from .utils import *
+from SpatialTransform import Transform
+
+
+class Local (unittest.TestCase):
+    def test_Init(self):
+        t = Transform()
+        self.assertEqual(glm.mat4(), t.Space)
+        self.assertEqual(glm.vec3(0), t.Position)
+        self.assertEqual(glm.quat(), t.Rotation)
+        self.assertEqual(glm.vec3(1), t.Scale)
+        self.assertEqual(glm.vec3(0,0,-1), t.Forward)
+        self.assertEqual(glm.vec3(1,0,0), t.Right)
+        self.assertEqual(glm.vec3(0,1,0), t.Up)
+
+        for _ in range(randomSamples):
+            position = randomPosition()
+            rotation = randomRotation()
+            scale = randomScale()
+
+            expected = (glm.translate(position) * glm.scale(scale)) * glm.mat4(rotation)
+            result = Transform(position=position, rotation=rotation, scale=scale)
+
+            self.assertEqual(expected, result.Space)
+            self.assertEqual(position, result.Position)
+            self.assertEqual(rotation, result.Rotation)
+            self.assertEqual(scale, result.Scale)
+            self.assertEqual(rotation * glm.vec3(0,0,-1), result.Forward)
+            self.assertEqual(rotation * glm.vec3(1,0,0), result.Right)
+            self.assertEqual(rotation * glm.vec3(0,1,0), result.Up)
+
+    def test_Reset(self):
+        t = Transform().reset()
+        self.assertEqual(glm.mat4(), t.Space)
+        self.assertEqual(glm.vec3(0), t.Position)
+        self.assertEqual(glm.quat(), t.Rotation)
+        self.assertEqual(glm.vec3(1), t.Scale)
+
+        t = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale()).reset()
+        self.assertEqual(glm.mat4(), t.Space)
+        self.assertEqual(glm.vec3(0), t.Position)
+        self.assertEqual(glm.quat(), t.Rotation)
+        self.assertEqual(glm.vec3(1), t.Scale)
+
+    def test_Space(self):
+        t = Transform()
+        for _ in range(randomSamples):
+            t.Position = randomPosition()
+            t.Rotation = randomRotation()
+            t.Scale = randomScale()
+            space = (glm.translate(t.Position) * glm.scale(t.Scale)) * glm.mat4(t.Rotation)
+            self.assertEqual(space, t.Space)
+
+    def test_Position(self):
+        t = Transform()
+        for _ in range(randomSamples):
+            position = randomPosition()
+            space = glm.translate(position)
+            t.Position = position
+            self.assertEqual(position, t.Position)
+            self.assertEqual(space, t.Space)
+
+    def test_Rotation(self):
+        t = Transform()
+        for _ in range(randomSamples):
+            rotation = randomRotation()
+            space = glm.mat4(rotation)
+            t.Rotation = rotation
+            self.assertGreater(deltaRotation, abs(1 - glm.length(t.Rotation)))
+            self.assertEqual(rotation, t.Rotation)
+            self.assertEqual(space, t.Space)
+            self.assertEqual(rotation * glm.vec3(0,0,-1), t.Forward)
+            self.assertEqual(rotation * glm.vec3(1,0,0), t.Right)
+            self.assertEqual(rotation * glm.vec3(0,1,0), t.Up)
+
+    def test_Scale(self):
+        t = Transform()
+        for _ in range(randomSamples):
+            scale = randomScale()
+            space = glm.scale(scale)
+            t.Scale = scale
+            self.assertEqual(scale, t.Scale)
+            self.assertEqual(space, t.Space)
+
+class World(unittest.TestCase):
+    def test_Init(self):
+        root = Transform()
+        child = Transform()
+        root.attach(child)
+
+        self.assertEqual(glm.mat4(), child.SpaceWorld)
+        self.assertEqual(glm.vec3(0), child.PositionWorld)
+        self.assertEqual(glm.quat(), child.RotationWorld)
+        self.assertEqual(glm.vec3(1), child.ScaleWorld)
+        self.assertEqual(glm.vec3(0,0,-1), child.ForwardWorld)
+        self.assertEqual(glm.vec3(1,0,0), child.RightWorld)
+        self.assertEqual(glm.vec3(0,1,0), child.UpWorld)
+
+        for _ in range(randomSamples):
+            root = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            child = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            root.attach(child)
+            self.assertEqual(root.Space * child.Space, child.SpaceWorld)
+            self.assertEqual(glm.inverse(root.Space * child.Space), child.SpaceWorldInverse)
+
+    def test_Reset(self):
+        root = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+        child = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+        root.attach(child)
+
+        child.reset()
+        self.assertEqual(child.SpaceWorld, root.SpaceWorld)
+        self.assertEqual(child.PositionWorld, root.PositionWorld)
+        self.assertEqual(child.RotationWorld, root.RotationWorld)
+        self.assertEqual(child.ScaleWorld, root.ScaleWorld)
+
+        root.reset()
+        self.assertEqual(glm.mat4(), child.SpaceWorld)
+        self.assertEqual(glm.vec3(0), child.PositionWorld)
+        self.assertEqual(glm.quat(), child.RotationWorld)
+        self.assertEqual(glm.vec3(1), child.ScaleWorld)
+
+    def test_Space(self):
+        root = Transform()
+        child = Transform()
+        root.attach(child)
+        for _ in range(randomSamples):
+            root.Position = randomPosition()
+            root.Rotation = randomRotation()
+            root.Scale = randomScale()
+
+            child.Position = randomPosition()
+            child.Rotation = randomRotation()
+            child.Scale = randomScale()
+
+            self.assertEqual(root.Space * child.Space, child.SpaceWorld)
+            self.assertEqual(glm.inverse(root.Space * child.Space), child.SpaceWorldInverse)
+
+    def test_Position(self):
+        root = Transform()
+        child = Transform()
+        root.attach(child)
+        for _ in range(randomSamples):
+            root.Position = randomPosition()
+            child.Position = randomPosition()
+            self.assertEqual(root.Space * child.Position, child.PositionWorld)
+
+    def test_Rotation(self):
+        root = Transform()
+        child = Transform()
+        root.attach(child)
+        for _ in range(randomSamples):
+            root.Rotation = randomRotation()
+            child.Rotation = randomRotation()
+            self.assertEqual(root.Rotation * child.Rotation, child.RotationWorld)
+            self.assertGreater(deltaRotation, abs(1 - glm.length(child.RotationWorld)))
+            self.assertEqual((root.Rotation * child.Rotation) * glm.vec3(0,0,-1), child.ForwardWorld)
+            self.assertEqual((root.Rotation * child.Rotation) * glm.vec3(1,0,0), child.RightWorld)
+            self.assertEqual((root.Rotation * child.Rotation) * glm.vec3(0,1,0), child.UpWorld)
+
+    def test_Scale(self):
+        root = Transform()
+        child = Transform()
+        root.attach(child)
+        for _ in range(randomSamples):
+            root.Scale = randomScale()
+            child.Scale = randomScale()
+            self.assertEqual(root.Scale * child.Scale, child.ScaleWorld)
+
+if __name__ == '__main__':
+    unittest.main()

env/kimodo/lib/python3.10/site-packages/SpatialTransform/tests/test_transform_extended.py

@@ -0,0 +1,268 @@
+import glm
+import unittest
+import re
+from .utils import *
+from SpatialTransform import Transform, Pose
+
+
+class TransformUtilities(unittest.TestCase):
+    def test_name_property(self):
+        """Test Name property getter and setter."""
+        t = Transform()
+        # Default name should be 8 random characters
+        self.assertEqual(8, len(t.Name))
+
+        # Test custom name
+        custom_name = "TestTransform"
+        t.Name = custom_name
+        self.assertEqual(custom_name, t.Name)
+
+        # Test name in constructor
+        t2 = Transform(name="ConstructorName")
+        self.assertEqual("ConstructorName", t2.Name)
+
+    def test_layout(self):
+        """Test layout method."""
+        root = Transform(name="Root")
+        child1 = Transform(name="Child1")
+        child2 = Transform(name="Child2")
+        grandchild = Transform(name="GrandChild")
+
+        root.attach(child1, child2)
+        child1.attach(grandchild)
+
+        layout = root.layout()
+
+        # Should return list of tuples [transform, index, depth]
+        self.assertEqual(4, len(layout))
+
+        # Check root
+        self.assertEqual(root, layout[0][0])
+        self.assertEqual(0, layout[0][1])  # index
+        self.assertEqual(0, layout[0][2])  # depth
+
+        # Check child1
+        self.assertEqual(child1, layout[1][0])
+        self.assertEqual(1, layout[1][1])
+        self.assertEqual(1, layout[1][2])
+
+        # Check grandchild
+        self.assertEqual(grandchild, layout[2][0])
+        self.assertEqual(2, layout[2][1])
+        self.assertEqual(2, layout[2][2])
+
+        # Check child2
+        self.assertEqual(child2, layout[3][0])
+        self.assertEqual(3, layout[3][1])
+        self.assertEqual(1, layout[3][2])
+
+    def test_filter(self):
+        """Test filter method."""
+        root = Transform(name="RootNode")
+        child1 = Transform(name="TestChild")
+        child2 = Transform(name="AnotherChild")
+        child3 = Transform(name="TestNode")
+
+        root.attach(child1, child2, child3)
+
+        # Test partial match (default)
+        results = root.filter("Test")
+        self.assertEqual(2, len(results))
+        self.assertIn(child1, results)
+        self.assertIn(child3, results)
+
+        # Test exact match
+        results = root.filter("TestChild", isEqual=True)
+        self.assertEqual(1, len(results))
+        self.assertEqual(child1, results[0])
+
+        # Test case sensitivity
+        results = root.filter("test", caseSensitive=False)
+        self.assertEqual(2, len(results))
+
+        results = root.filter("test", caseSensitive=True)
+        self.assertEqual(0, len(results))
+
+        # Test no matches
+        results = root.filter("NonExistent")
+        self.assertEqual(0, len(results))
+
+    def test_filter_regex(self):
+        """Test filterRegex method."""
+        root = Transform(name="Root")
+        child1 = Transform(name="Test123")
+        child2 = Transform(name="AnotherChild")
+        child3 = Transform(name="Test456")
+
+        root.attach(child1, child2, child3)
+
+        # Test regex pattern
+        results = root.filterRegex(r"Test\d+")
+        self.assertEqual(2, len(results))
+        self.assertIn(child1, results)
+        self.assertIn(child3, results)
+
+        # Test exact match regex
+        results = root.filterRegex("^Root$")
+        self.assertEqual(1, len(results))
+        self.assertEqual(root, results[0])
+
+        # Test no matches
+        results = root.filterRegex(r"Node\d+")
+        self.assertEqual(0, len(results))
+
+    def test_print_tree(self):
+        """Test printTree method (verify it doesn't crash)."""
+        root = Transform(name="Root")
+        child1 = Transform(name="Child1")
+        child2 = Transform(name="Child2")
+        grandchild = Transform(name="GrandChild")
+
+        root.attach(child1, child2)
+        child1.attach(grandchild)
+
+        # This should not crash
+        import io
+        import sys
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        root.printTree()
+        sys.stdout = sys.__stdout__
+
+        output = captured_output.getvalue()
+        self.assertIn("Root", output)
+        self.assertIn("Child1", output)
+        self.assertIn("Child2", output)
+        self.assertIn("GrandChild", output)
+
+    def test_to_pose(self):
+        """Test toPose method."""
+        for _ in range(randomSamples):
+            position = randomPosition()
+            rotation = randomRotation()
+            scale = randomScale()
+
+            t = Transform(position=position, rotation=rotation, scale=scale)
+
+            # Test local space
+            pose_local = t.toPose(worldSpace=False)
+            self.assertEqual(position, pose_local.Position)
+            self.assertEqual(rotation, pose_local.Rotation)
+            self.assertEqual(scale, pose_local.Scale)
+
+            # Test world space with parent
+            parent = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+            parent.attach(t)
+
+            pose_world = t.toPose(worldSpace=True)
+            self.assertEqual(t.PositionWorld, pose_world.Position)
+            self.assertEqual(t.RotationWorld, pose_world.Rotation)
+            self.assertEqual(t.ScaleWorld, pose_world.Scale)
+
+    def test_from_pose(self):
+        """Test fromPose static method."""
+        for _ in range(randomSamples):
+            pose = Pose(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+
+            # Test without name
+            t = Transform.fromPose(pose)
+            self.assertEqual(pose.Position, t.Position)
+            self.assertEqual(pose.Rotation, t.Rotation)
+            self.assertEqual(pose.Scale, t.Scale)
+
+            # Test with name
+            custom_name = "FromPoseTest"
+            t_named = Transform.fromPose(pose, name=custom_name)
+            self.assertEqual(custom_name, t_named.Name)
+            self.assertEqual(pose.Position, t_named.Position)
+            self.assertEqual(pose.Rotation, t_named.Rotation)
+            self.assertEqual(pose.Scale, t_named.Scale)
+
+
+class TransformEdgeCases(unittest.TestCase):
+    def test_duplicate_recursive(self):
+        """Test duplicate with recursive=True."""
+        root = Transform(name="Root", position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+        child1 = Transform(name="Child1", position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+        child2 = Transform(name="Child2", position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+        grandchild = Transform(name="GrandChild", position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+
+        root.attach(child1, child2)
+        child1.attach(grandchild)
+
+        # Test recursive duplicate
+        duplicate = root.duplicate(recursive=True)
+
+        # Should be different objects
+        self.assertNotEqual(root, duplicate)
+        self.assertNotEqual(child1, duplicate.Children[0])
+
+        # But same properties
+        self.assertEqual(root.Name, duplicate.Name)
+        self.assertEqual(len(root.Children), len(duplicate.Children))
+        self.assertEqual(child1.Name, duplicate.Children[0].Name)
+
+        # Check hierarchy integrity
+        self.assertEqual(duplicate, duplicate.Children[0].Parent)
+        self.assertEqual(1, len(duplicate.Children[0].Children))  # grandchild
+
+    def test_duplicate_non_recursive(self):
+        """Test duplicate with recursive=False."""
+        root = Transform(name="Root", position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+        child = Transform(name="Child", position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+
+        root.attach(child)
+
+        # Test non-recursive duplicate
+        duplicate = root.duplicate(recursive=False)
+
+        # Should be different object
+        self.assertNotEqual(root, duplicate)
+
+        # Same properties but no children
+        self.assertEqual(root.Name, duplicate.Name)
+        self.assertEqual(0, len(duplicate.Children))
+
+    def test_reset_recursive(self):
+        """Test reset with recursive=True."""
+        root = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+        child = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+
+        root.attach(child)
+
+        # Reset recursively
+        root.reset(recursive=True)
+
+        # Both should be reset
+        self.assertEqual(glm.vec3(0), root.Position)
+        self.assertEqual(glm.quat(), root.Rotation)
+        self.assertEqual(glm.vec3(1), root.Scale)
+
+        self.assertEqual(glm.vec3(0), child.Position)
+        self.assertEqual(glm.quat(), child.Rotation)
+        self.assertEqual(glm.vec3(1), child.Scale)
+
+    def test_world_property_setters(self):
+        """Test world space property setters."""
+        parent = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+        child = Transform(position=randomPosition(), rotation=randomRotation(), scale=randomScale())
+        parent.attach(child)
+
+        # Test PositionWorld setter
+        new_world_pos = randomPosition()
+        child.PositionWorld = new_world_pos
+        self.assertGreater(deltaPosition, glm.distance2(new_world_pos, child.PositionWorld))
+
+        # Test RotationWorld setter
+        new_world_rot = randomRotation()
+        child.RotationWorld = new_world_rot
+        self.assertGreater(deltaRotation, glm.angle(new_world_rot * glm.inverse(child.RotationWorld)))
+
+        # Test ScaleWorld setter
+        new_world_scale = randomScale()
+        child.ScaleWorld = new_world_scale
+        self.assertGreater(deltaPosition, glm.distance2(new_world_scale, child.ScaleWorld))
+
+
+if __name__ == '__main__':
+    unittest.main()

env/kimodo/lib/python3.10/site-packages/SpatialTransform/tests/utils.py

@@ -0,0 +1,31 @@
+import glm
+import math
+import random
+
+deltaPosition = 1e-05
+deltaRotation = 1e-05
+deltaScale = 1e-05
+randomSamples = 1000
+
+
+def randomPosition():
+    return glm.vec3(random.random(), random.random(), random.random()) * 2 - 1
+
+def randomDirection():
+    result = glm.vec3(random.random(), random.random(), random.random())
+    theta = result.x * math.pi * 2.0
+    phi = math.acos((2.0 * result.y) - 1.0)
+    r = pow(result.z, 1/3)
+
+    result.x = r * math.sin(phi) * math.cos(theta)
+    result.y = r * math.sin(phi) * math.sin(theta)
+    result.z = r * math.cos(phi)
+
+    return glm.normalize(result)
+
+def randomRotation():
+    return glm.normalize(glm.quatLookAtRH(randomDirection(), (0,1,0)))
+
+def randomScale():
+    return (glm.vec3(random.random(), random.random(), random.random()) + 0.01) * \
+         glm.vec3(-1 if random.random()<0.5 else 1, -1 if random.random()<0.5 else 1, -1 if random.random()<0.5 else 1)

env/kimodo/lib/python3.10/site-packages/_yaml/__init__.py

@@ -0,0 +1,33 @@
+# This is a stub package designed to roughly emulate the _yaml
+# extension module, which previously existed as a standalone module
+# and has been moved into the `yaml` package namespace.
+# It does not perfectly mimic its old counterpart, but should get
+# close enough for anyone who's relying on it even when they shouldn't.
+import yaml
+
+# in some circumstances, the yaml module we imoprted may be from a different version, so we need
+# to tread carefully when poking at it here (it may not have the attributes we expect)
+if not getattr(yaml, '__with_libyaml__', False):
+    from sys import version_info
+
+    exc = ModuleNotFoundError if version_info >= (3, 6) else ImportError
+    raise exc("No module named '_yaml'")
+else:
+    from yaml._yaml import *
+    import warnings
+    warnings.warn(
+        'The _yaml extension module is now located at yaml._yaml'
+        ' and its location is subject to change.  To use the'
+        ' LibYAML-based parser and emitter, import from `yaml`:'
+        ' `from yaml import CLoader as Loader, CDumper as Dumper`.',
+        DeprecationWarning
+    )
+    del warnings
+    # Don't `del yaml` here because yaml is actually an existing
+    # namespace member of _yaml.
+
+__name__ = '_yaml'
+# If the module is top-level (i.e. not a part of any specific package)
+# then the attribute should be set to ''.
+# https://docs.python.org/3.8/library/types.html
+__package__ = ''

env/kimodo/lib/python3.10/site-packages/multipart/__init__.py

@@ -0,0 +1,24 @@
+# This only works if using a file system, other loaders not implemented.
+
+import importlib.util
+import sys
+import warnings
+from pathlib import Path
+
+for p in sys.path:
+    file_path = Path(p, "multipart.py")
+    try:
+        if file_path.is_file():
+            spec = importlib.util.spec_from_file_location("multipart", file_path)
+            assert spec is not None, f"{file_path} found but not loadable!"
+            module = importlib.util.module_from_spec(spec)
+            sys.modules["multipart"] = module
+            assert spec.loader is not None, f"{file_path} must be loadable!"
+            spec.loader.exec_module(module)
+            break
+    except PermissionError:
+        pass
+else:
+    warnings.warn("Please use `import python_multipart` instead.", PendingDeprecationWarning, stacklevel=2)
+    from python_multipart import *
+    from python_multipart import __all__, __author__, __copyright__, __license__, __version__

env/kimodo/lib/python3.10/site-packages/multipart/decoders.py

@@ -0,0 +1 @@
+from python_multipart.decoders import *

env/kimodo/lib/python3.10/site-packages/multipart/exceptions.py

@@ -0,0 +1 @@
+from python_multipart.exceptions import *

env/kimodo/lib/python3.10/site-packages/multipart/multipart.py

@@ -0,0 +1 @@
+from python_multipart.multipart import *

env/kimodo/lib/python3.10/site-packages/pygments/__init__.py

@@ -0,0 +1,82 @@
+"""
+    Pygments
+    ~~~~~~~~
+
+    Pygments is a syntax highlighting package written in Python.
+
+    It is a generic syntax highlighter for general use in all kinds of software
+    such as forum systems, wikis or other applications that need to prettify
+    source code. Highlights are:
+
+    * a wide range of common languages and markup formats is supported
+    * special attention is paid to details, increasing quality by a fair amount
+    * support for new languages and formats are added easily
+    * a number of output formats, presently HTML, LaTeX, RTF, SVG, all image
+      formats that PIL supports, and ANSI sequences
+    * it is usable as a command-line tool and as a library
+    * ... and it highlights even Brainfuck!
+
+    The `Pygments master branch`_ is installable with ``easy_install Pygments==dev``.
+
+    .. _Pygments master branch:
+       https://github.com/pygments/pygments/archive/master.zip#egg=Pygments-dev
+
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+from io import StringIO, BytesIO
+
+__version__ = '2.19.2'
+__docformat__ = 'restructuredtext'
+
+__all__ = ['lex', 'format', 'highlight']
+
+
+def lex(code, lexer):
+    """
+    Lex `code` with the `lexer` (must be a `Lexer` instance)
+    and return an iterable of tokens. Currently, this only calls
+    `lexer.get_tokens()`.
+    """
+    try:
+        return lexer.get_tokens(code)
+    except TypeError:
+        # Heuristic to catch a common mistake.
+        from pygments.lexer import RegexLexer
+        if isinstance(lexer, type) and issubclass(lexer, RegexLexer):
+            raise TypeError('lex() argument must be a lexer instance, '
+                            'not a class')
+        raise
+
+
+def format(tokens, formatter, outfile=None):  # pylint: disable=redefined-builtin
+    """
+    Format ``tokens`` (an iterable of tokens) with the formatter ``formatter``
+    (a `Formatter` instance).
+
+    If ``outfile`` is given and a valid file object (an object with a
+    ``write`` method), the result will be written to it, otherwise it
+    is returned as a string.
+    """
+    try:
+        if not outfile:
+            realoutfile = getattr(formatter, 'encoding', None) and BytesIO() or StringIO()
+            formatter.format(tokens, realoutfile)
+            return realoutfile.getvalue()
+        else:
+            formatter.format(tokens, outfile)
+    except TypeError:
+        # Heuristic to catch a common mistake.
+        from pygments.formatter import Formatter
+        if isinstance(formatter, type) and issubclass(formatter, Formatter):
+            raise TypeError('format() argument must be a formatter instance, '
+                            'not a class')
+        raise
+
+
+def highlight(code, lexer, formatter, outfile=None):
+    """
+    This is the most high-level highlighting function. It combines `lex` and
+    `format` in one function.
+    """
+    return format(lex(code, lexer), formatter, outfile)

env/kimodo/lib/python3.10/site-packages/pygments/__main__.py

@@ -0,0 +1,17 @@
+"""
+    pygments.__main__
+    ~~~~~~~~~~~~~~~~~
+
+    Main entry point for ``python -m pygments``.
+
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import sys
+import pygments.cmdline
+
+try:
+    sys.exit(pygments.cmdline.main(sys.argv))
+except KeyboardInterrupt:
+    sys.exit(1)

env/kimodo/lib/python3.10/site-packages/pygments/cmdline.py

@@ -0,0 +1,668 @@
+"""
+    pygments.cmdline
+    ~~~~~~~~~~~~~~~~
+
+    Command line interface.
+
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import os
+import sys
+import shutil
+import argparse
+from textwrap import dedent
+
+from pygments import __version__, highlight
+from pygments.util import ClassNotFound, OptionError, docstring_headline, \
+    guess_decode, guess_decode_from_terminal, terminal_encoding, \
+    UnclosingTextIOWrapper
+from pygments.lexers import get_all_lexers, get_lexer_by_name, guess_lexer, \
+    load_lexer_from_file, get_lexer_for_filename, find_lexer_class_for_filename
+from pygments.lexers.special import TextLexer
+from pygments.formatters.latex import LatexEmbeddedLexer, LatexFormatter
+from pygments.formatters import get_all_formatters, get_formatter_by_name, \
+    load_formatter_from_file, get_formatter_for_filename, find_formatter_class
+from pygments.formatters.terminal import TerminalFormatter
+from pygments.formatters.terminal256 import Terminal256Formatter, TerminalTrueColorFormatter
+from pygments.filters import get_all_filters, find_filter_class
+from pygments.styles import get_all_styles, get_style_by_name
+
+
+def _parse_options(o_strs):
+    opts = {}
+    if not o_strs:
+        return opts
+    for o_str in o_strs:
+        if not o_str.strip():
+            continue
+        o_args = o_str.split(',')
+        for o_arg in o_args:
+            o_arg = o_arg.strip()
+            try:
+                o_key, o_val = o_arg.split('=', 1)
+                o_key = o_key.strip()
+                o_val = o_val.strip()
+            except ValueError:
+                opts[o_arg] = True
+            else:
+                opts[o_key] = o_val
+    return opts
+
+
+def _parse_filters(f_strs):
+    filters = []
+    if not f_strs:
+        return filters
+    for f_str in f_strs:
+        if ':' in f_str:
+            fname, fopts = f_str.split(':', 1)
+            filters.append((fname, _parse_options([fopts])))
+        else:
+            filters.append((f_str, {}))
+    return filters
+
+
+def _print_help(what, name):
+    try:
+        if what == 'lexer':
+            cls = get_lexer_by_name(name)
+            print(f"Help on the {cls.name} lexer:")
+            print(dedent(cls.__doc__))
+        elif what == 'formatter':
+            cls = find_formatter_class(name)
+            print(f"Help on the {cls.name} formatter:")
+            print(dedent(cls.__doc__))
+        elif what == 'filter':
+            cls = find_filter_class(name)
+            print(f"Help on the {name} filter:")
+            print(dedent(cls.__doc__))
+        return 0
+    except (AttributeError, ValueError):
+        print(f"{what} not found!", file=sys.stderr)
+        return 1
+
+
+def _print_list(what):
+    if what == 'lexer':
+        print()
+        print("Lexers:")
+        print("~~~~~~~")
+
+        info = []
+        for fullname, names, exts, _ in get_all_lexers():
+            tup = (', '.join(names)+':', fullname,
+                   exts and '(filenames ' + ', '.join(exts) + ')' or '')
+            info.append(tup)
+        info.sort()
+        for i in info:
+            print(('* {}\n    {} {}').format(*i))
+
+    elif what == 'formatter':
+        print()
+        print("Formatters:")
+        print("~~~~~~~~~~~")
+
+        info = []
+        for cls in get_all_formatters():
+            doc = docstring_headline(cls)
+            tup = (', '.join(cls.aliases) + ':', doc, cls.filenames and
+                   '(filenames ' + ', '.join(cls.filenames) + ')' or '')
+            info.append(tup)
+        info.sort()
+        for i in info:
+            print(('* {}\n    {} {}').format(*i))
+
+    elif what == 'filter':
+        print()
+        print("Filters:")
+        print("~~~~~~~~")
+
+        for name in get_all_filters():
+            cls = find_filter_class(name)
+            print("* " + name + ':')
+            print(f"    {docstring_headline(cls)}")
+
+    elif what == 'style':
+        print()
+        print("Styles:")
+        print("~~~~~~~")
+
+        for name in get_all_styles():
+            cls = get_style_by_name(name)
+            print("* " + name + ':')
+            print(f"    {docstring_headline(cls)}")
+
+
+def _print_list_as_json(requested_items):
+    import json
+    result = {}
+    if 'lexer' in requested_items:
+        info = {}
+        for fullname, names, filenames, mimetypes in get_all_lexers():
+            info[fullname] = {
+                'aliases': names,
+                'filenames': filenames,
+                'mimetypes': mimetypes
+            }
+        result['lexers'] = info
+
+    if 'formatter' in requested_items:
+        info = {}
+        for cls in get_all_formatters():
+            doc = docstring_headline(cls)
+            info[cls.name] = {
+                'aliases': cls.aliases,
+                'filenames': cls.filenames,
+                'doc': doc
+            }
+        result['formatters'] = info
+
+    if 'filter' in requested_items:
+        info = {}
+        for name in get_all_filters():
+            cls = find_filter_class(name)
+            info[name] = {
+                'doc': docstring_headline(cls)
+            }
+        result['filters'] = info
+
+    if 'style' in requested_items:
+        info = {}
+        for name in get_all_styles():
+            cls = get_style_by_name(name)
+            info[name] = {
+                'doc': docstring_headline(cls)
+            }
+        result['styles'] = info
+
+    json.dump(result, sys.stdout)
+
+def main_inner(parser, argns):
+    if argns.help:
+        parser.print_help()
+        return 0
+
+    if argns.V:
+        print(f'Pygments version {__version__}, (c) 2006-2024 by Georg Brandl, Matthäus '
+              'Chajdas and contributors.')
+        return 0
+
+    def is_only_option(opt):
+        return not any(v for (k, v) in vars(argns).items() if k != opt)
+
+    # handle ``pygmentize -L``
+    if argns.L is not None:
+        arg_set = set()
+        for k, v in vars(argns).items():
+            if v:
+                arg_set.add(k)
+
+        arg_set.discard('L')
+        arg_set.discard('json')
+
+        if arg_set:
+            parser.print_help(sys.stderr)
+            return 2
+
+        # print version
+        if not argns.json:
+            main(['', '-V'])
+        allowed_types = {'lexer', 'formatter', 'filter', 'style'}
+        largs = [arg.rstrip('s') for arg in argns.L]
+        if any(arg not in allowed_types for arg in largs):
+            parser.print_help(sys.stderr)
+            return 0
+        if not largs:
+            largs = allowed_types
+        if not argns.json:
+            for arg in largs:
+                _print_list(arg)
+        else:
+            _print_list_as_json(largs)
+        return 0
+
+    # handle ``pygmentize -H``
+    if argns.H:
+        if not is_only_option('H'):
+            parser.print_help(sys.stderr)
+            return 2
+        what, name = argns.H
+        if what not in ('lexer', 'formatter', 'filter'):
+            parser.print_help(sys.stderr)
+            return 2
+        return _print_help(what, name)
+
+    # parse -O options
+    parsed_opts = _parse_options(argns.O or [])
+
+    # parse -P options
+    for p_opt in argns.P or []:
+        try:
+            name, value = p_opt.split('=', 1)
+        except ValueError:
+            parsed_opts[p_opt] = True
+        else:
+            parsed_opts[name] = value
+
+    # encodings
+    inencoding = parsed_opts.get('inencoding', parsed_opts.get('encoding'))
+    outencoding = parsed_opts.get('outencoding', parsed_opts.get('encoding'))
+
+    # handle ``pygmentize -N``
+    if argns.N:
+        lexer = find_lexer_class_for_filename(argns.N)
+        if lexer is None:
+            lexer = TextLexer
+
+        print(lexer.aliases[0])
+        return 0
+
+    # handle ``pygmentize -C``
+    if argns.C:
+        inp = sys.stdin.buffer.read()
+        try:
+            lexer = guess_lexer(inp, inencoding=inencoding)
+        except ClassNotFound:
+            lexer = TextLexer
+
+        print(lexer.aliases[0])
+        return 0
+
+    # handle ``pygmentize -S``
+    S_opt = argns.S
+    a_opt = argns.a
+    if S_opt is not None:
+        f_opt = argns.f
+        if not f_opt:
+            parser.print_help(sys.stderr)
+            return 2
+        if argns.l or argns.INPUTFILE:
+            parser.print_help(sys.stderr)
+            return 2
+
+        try:
+            parsed_opts['style'] = S_opt
+            fmter = get_formatter_by_name(f_opt, **parsed_opts)
+        except ClassNotFound as err:
+            print(err, file=sys.stderr)
+            return 1
+
+        print(fmter.get_style_defs(a_opt or ''))
+        return 0
+
+    # if no -S is given, -a is not allowed
+    if argns.a is not None:
+        parser.print_help(sys.stderr)
+        return 2
+
+    # parse -F options
+    F_opts = _parse_filters(argns.F or [])
+
+    # -x: allow custom (eXternal) lexers and formatters
+    allow_custom_lexer_formatter = bool(argns.x)
+
+    # select lexer
+    lexer = None
+
+    # given by name?
+    lexername = argns.l
+    if lexername:
+        # custom lexer, located relative to user's cwd
+        if allow_custom_lexer_formatter and '.py' in lexername:
+            try:
+                filename = None
+                name = None
+                if ':' in lexername:
+                    filename, name = lexername.rsplit(':', 1)
+
+                    if '.py' in name:
+                        # This can happen on Windows: If the lexername is
+                        # C:\lexer.py -- return to normal load path in that case
+                        name = None
+
+                if filename and name:
+                    lexer = load_lexer_from_file(filename, name,
+                                                 **parsed_opts)
+                else:
+                    lexer = load_lexer_from_file(lexername, **parsed_opts)
+            except ClassNotFound as err:
+                print('Error:', err, file=sys.stderr)
+                return 1
+        else:
+            try:
+                lexer = get_lexer_by_name(lexername, **parsed_opts)
+            except (OptionError, ClassNotFound) as err:
+                print('Error:', err, file=sys.stderr)
+                return 1
+
+    # read input code
+    code = None
+
+    if argns.INPUTFILE:
+        if argns.s:
+            print('Error: -s option not usable when input file specified',
+                  file=sys.stderr)
+            return 2
+
+        infn = argns.INPUTFILE
+        try:
+            with open(infn, 'rb') as infp:
+                code = infp.read()
+        except Exception as err:
+            print('Error: cannot read infile:', err, file=sys.stderr)
+            return 1
+        if not inencoding:
+            code, inencoding = guess_decode(code)
+
+        # do we have to guess the lexer?
+        if not lexer:
+            try:
+                lexer = get_lexer_for_filename(infn, code, **parsed_opts)
+            except ClassNotFound as err:
+                if argns.g:
+                    try:
+                        lexer = guess_lexer(code, **parsed_opts)
+                    except ClassNotFound:
+                        lexer = TextLexer(**parsed_opts)
+                else:
+                    print('Error:', err, file=sys.stderr)
+                    return 1
+            except OptionError as err:
+                print('Error:', err, file=sys.stderr)
+                return 1
+
+    elif not argns.s:  # treat stdin as full file (-s support is later)
+        # read code from terminal, always in binary mode since we want to
+        # decode ourselves and be tolerant with it
+        code = sys.stdin.buffer.read()  # use .buffer to get a binary stream
+        if not inencoding:
+            code, inencoding = guess_decode_from_terminal(code, sys.stdin)
+            # else the lexer will do the decoding
+        if not lexer:
+            try:
+                lexer = guess_lexer(code, **parsed_opts)
+            except ClassNotFound:
+                lexer = TextLexer(**parsed_opts)
+
+    else:  # -s option needs a lexer with -l
+        if not lexer:
+            print('Error: when using -s a lexer has to be selected with -l',
+                  file=sys.stderr)
+            return 2
+
+    # process filters
+    for fname, fopts in F_opts:
+        try:
+            lexer.add_filter(fname, **fopts)
+        except ClassNotFound as err:
+            print('Error:', err, file=sys.stderr)
+            return 1
+
+    # select formatter
+    outfn = argns.o
+    fmter = argns.f
+    if fmter:
+        # custom formatter, located relative to user's cwd
+        if allow_custom_lexer_formatter and '.py' in fmter:
+            try:
+                filename = None
+                name = None
+                if ':' in fmter:
+                    # Same logic as above for custom lexer
+                    filename, name = fmter.rsplit(':', 1)
+
+                    if '.py' in name:
+                        name = None
+
+                if filename and name:
+                    fmter = load_formatter_from_file(filename, name,
+                                                     **parsed_opts)
+                else:
+                    fmter = load_formatter_from_file(fmter, **parsed_opts)
+            except ClassNotFound as err:
+                print('Error:', err, file=sys.stderr)
+                return 1
+        else:
+            try:
+                fmter = get_formatter_by_name(fmter, **parsed_opts)
+            except (OptionError, ClassNotFound) as err:
+                print('Error:', err, file=sys.stderr)
+                return 1
+
+    if outfn:
+        if not fmter:
+            try:
+                fmter = get_formatter_for_filename(outfn, **parsed_opts)
+            except (OptionError, ClassNotFound) as err:
+                print('Error:', err, file=sys.stderr)
+                return 1
+        try:
+            outfile = open(outfn, 'wb')
+        except Exception as err:
+            print('Error: cannot open outfile:', err, file=sys.stderr)
+            return 1
+    else:
+        if not fmter:
+            if os.environ.get('COLORTERM','') in ('truecolor', '24bit'):
+                fmter = TerminalTrueColorFormatter(**parsed_opts)
+            elif '256' in os.environ.get('TERM', ''):
+                fmter = Terminal256Formatter(**parsed_opts)
+            else:
+                fmter = TerminalFormatter(**parsed_opts)
+        outfile = sys.stdout.buffer
+
+    # determine output encoding if not explicitly selected
+    if not outencoding:
+        if outfn:
+            # output file? use lexer encoding for now (can still be None)
+            fmter.encoding = inencoding
+        else:
+            # else use terminal encoding
+            fmter.encoding = terminal_encoding(sys.stdout)
+
+    # provide coloring under Windows, if possible
+    if not outfn and sys.platform in ('win32', 'cygwin') and \
+       fmter.name in ('Terminal', 'Terminal256'):  # pragma: no cover
+        # unfortunately colorama doesn't support binary streams on Py3
+        outfile = UnclosingTextIOWrapper(outfile, encoding=fmter.encoding)
+        fmter.encoding = None
+        try:
+            import colorama.initialise
+        except ImportError:
+            pass
+        else:
+            outfile = colorama.initialise.wrap_stream(
+                outfile, convert=None, strip=None, autoreset=False, wrap=True)
+
+    # When using the LaTeX formatter and the option `escapeinside` is
+    # specified, we need a special lexer which collects escaped text
+    # before running the chosen language lexer.
+    escapeinside = parsed_opts.get('escapeinside', '')
+    if len(escapeinside) == 2 and isinstance(fmter, LatexFormatter):
+        left = escapeinside[0]
+        right = escapeinside[1]
+        lexer = LatexEmbeddedLexer(left, right, lexer)
+
+    # ... and do it!
+    if not argns.s:
+        # process whole input as per normal...
+        try:
+            highlight(code, lexer, fmter, outfile)
+        finally:
+            if outfn:
+                outfile.close()
+        return 0
+    else:
+        # line by line processing of stdin (eg: for 'tail -f')...
+        try:
+            while 1:
+                line = sys.stdin.buffer.readline()
+                if not line:
+                    break
+                if not inencoding:
+                    line = guess_decode_from_terminal(line, sys.stdin)[0]
+                highlight(line, lexer, fmter, outfile)
+                if hasattr(outfile, 'flush'):
+                    outfile.flush()
+            return 0
+        except KeyboardInterrupt:  # pragma: no cover
+            return 0
+        finally:
+            if outfn:
+                outfile.close()
+
+
+class HelpFormatter(argparse.HelpFormatter):
+    def __init__(self, prog, indent_increment=2, max_help_position=16, width=None):
+        if width is None:
+            try:
+                width = shutil.get_terminal_size().columns - 2
+            except Exception:
+                pass
+        argparse.HelpFormatter.__init__(self, prog, indent_increment,
+                                        max_help_position, width)
+
+
+def main(args=sys.argv):
+    """
+    Main command line entry point.
+    """
+    desc = "Highlight an input file and write the result to an output file."
+    parser = argparse.ArgumentParser(description=desc, add_help=False,
+                                     formatter_class=HelpFormatter)
+
+    operation = parser.add_argument_group('Main operation')
+    lexersel = operation.add_mutually_exclusive_group()
+    lexersel.add_argument(
+        '-l', metavar='LEXER',
+        help='Specify the lexer to use.  (Query names with -L.)  If not '
+        'given and -g is not present, the lexer is guessed from the filename.')
+    lexersel.add_argument(
+        '-g', action='store_true',
+        help='Guess the lexer from the file contents, or pass through '
+        'as plain text if nothing can be guessed.')
+    operation.add_argument(
+        '-F', metavar='FILTER[:options]', action='append',
+        help='Add a filter to the token stream.  (Query names with -L.) '
+        'Filter options are given after a colon if necessary.')
+    operation.add_argument(
+        '-f', metavar='FORMATTER',
+        help='Specify the formatter to use.  (Query names with -L.) '
+        'If not given, the formatter is guessed from the output filename, '
+        'and defaults to the terminal formatter if the output is to the '
+        'terminal or an unknown file extension.')
+    operation.add_argument(
+        '-O', metavar='OPTION=value[,OPTION=value,...]', action='append',
+        help='Give options to the lexer and formatter as a comma-separated '
+        'list of key-value pairs. '
+        'Example: `-O bg=light,python=cool`.')
+    operation.add_argument(
+        '-P', metavar='OPTION=value', action='append',
+        help='Give a single option to the lexer and formatter - with this '
+        'you can pass options whose value contains commas and equal signs. '
+        'Example: `-P "heading=Pygments, the Python highlighter"`.')
+    operation.add_argument(
+        '-o', metavar='OUTPUTFILE',
+        help='Where to write the output.  Defaults to standard output.')
+
+    operation.add_argument(
+        'INPUTFILE', nargs='?',
+        help='Where to read the input.  Defaults to standard input.')
+
+    flags = parser.add_argument_group('Operation flags')
+    flags.add_argument(
+        '-v', action='store_true',
+        help='Print a detailed traceback on unhandled exceptions, which '
+        'is useful for debugging and bug reports.')
+    flags.add_argument(
+        '-s', action='store_true',
+        help='Process lines one at a time until EOF, rather than waiting to '
+        'process the entire file.  This only works for stdin, only for lexers '
+        'with no line-spanning constructs, and is intended for streaming '
+        'input such as you get from `tail -f`. '
+        'Example usage: `tail -f sql.log | pygmentize -s -l sql`.')
+    flags.add_argument(
+        '-x', action='store_true',
+        help='Allow custom lexers and formatters to be loaded from a .py file '
+        'relative to the current working directory. For example, '
+        '`-l ./customlexer.py -x`. By default, this option expects a file '
+        'with a class named CustomLexer or CustomFormatter; you can also '
+        'specify your own class name with a colon (`-l ./lexer.py:MyLexer`). '
+        'Users should be very careful not to use this option with untrusted '
+        'files, because it will import and run them.')
+    flags.add_argument('--json', help='Output as JSON. This can '
+        'be only used in conjunction with -L.',
+        default=False,
+        action='store_true')
+
+    special_modes_group = parser.add_argument_group(
+        'Special modes - do not do any highlighting')
+    special_modes = special_modes_group.add_mutually_exclusive_group()
+    special_modes.add_argument(
+        '-S', metavar='STYLE -f formatter',
+        help='Print style definitions for STYLE for a formatter '
+        'given with -f. The argument given by -a is formatter '
+        'dependent.')
+    special_modes.add_argument(
+        '-L', nargs='*', metavar='WHAT',
+        help='List lexers, formatters, styles or filters -- '
+        'give additional arguments for the thing(s) you want to list '
+        '(e.g. "styles"), or omit them to list everything.')
+    special_modes.add_argument(
+        '-N', metavar='FILENAME',
+        help='Guess and print out a lexer name based solely on the given '
+        'filename. Does not take input or highlight anything. If no specific '
+        'lexer can be determined, "text" is printed.')
+    special_modes.add_argument(
+        '-C', action='store_true',
+        help='Like -N, but print out a lexer name based solely on '
+        'a given content from standard input.')
+    special_modes.add_argument(
+        '-H', action='store', nargs=2, metavar=('NAME', 'TYPE'),
+        help='Print detailed help for the object <name> of type <type>, '
+        'where <type> is one of "lexer", "formatter" or "filter".')
+    special_modes.add_argument(
+        '-V', action='store_true',
+        help='Print the package version.')
+    special_modes.add_argument(
+        '-h', '--help', action='store_true',
+        help='Print this help.')
+    special_modes_group.add_argument(
+        '-a', metavar='ARG',
+        help='Formatter-specific additional argument for the -S (print '
+        'style sheet) mode.')
+
+    argns = parser.parse_args(args[1:])
+
+    try:
+        return main_inner(parser, argns)
+    except BrokenPipeError:
+        # someone closed our stdout, e.g. by quitting a pager.
+        return 0
+    except Exception:
+        if argns.v:
+            print(file=sys.stderr)
+            print('*' * 65, file=sys.stderr)
+            print('An unhandled exception occurred while highlighting.',
+                  file=sys.stderr)
+            print('Please report the whole traceback to the issue tracker at',
+                  file=sys.stderr)
+            print('<https://github.com/pygments/pygments/issues>.',
+                  file=sys.stderr)
+            print('*' * 65, file=sys.stderr)
+            print(file=sys.stderr)
+            raise
+        import traceback
+        info = traceback.format_exception(*sys.exc_info())
+        msg = info[-1].strip()
+        if len(info) >= 3:
+            # extract relevant file and position info
+            msg += '\n   (f{})'.format(info[-2].split('\n')[0].strip()[1:])
+        print(file=sys.stderr)
+        print('*** Error while highlighting:', file=sys.stderr)
+        print(msg, file=sys.stderr)
+        print('*** If this is a bug you want to report, please rerun with -v.',
+              file=sys.stderr)
+        return 1

env/kimodo/lib/python3.10/site-packages/pygments/console.py

@@ -0,0 +1,70 @@
+"""
+    pygments.console
+    ~~~~~~~~~~~~~~~~
+
+    Format colored console output.
+
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+esc = "\x1b["
+
+codes = {}
+codes[""] = ""
+codes["reset"] = esc + "39;49;00m"
+
+codes["bold"] = esc + "01m"
+codes["faint"] = esc + "02m"
+codes["standout"] = esc + "03m"
+codes["underline"] = esc + "04m"
+codes["blink"] = esc + "05m"
+codes["overline"] = esc + "06m"
+
+dark_colors = ["black", "red", "green", "yellow", "blue",
+               "magenta", "cyan", "gray"]
+light_colors = ["brightblack", "brightred", "brightgreen", "brightyellow", "brightblue",
+                "brightmagenta", "brightcyan", "white"]
+
+x = 30
+for dark, light in zip(dark_colors, light_colors):
+    codes[dark] = esc + "%im" % x
+    codes[light] = esc + "%im" % (60 + x)
+    x += 1
+
+del dark, light, x
+
+codes["white"] = codes["bold"]
+
+
+def reset_color():
+    return codes["reset"]
+
+
+def colorize(color_key, text):
+    return codes[color_key] + text + codes["reset"]
+
+
+def ansiformat(attr, text):
+    """
+    Format ``text`` with a color and/or some attributes::
+
+        color       normal color
+        *color*     bold color
+        _color_     underlined color
+        +color+     blinking color
+    """
+    result = []
+    if attr[:1] == attr[-1:] == '+':
+        result.append(codes['blink'])
+        attr = attr[1:-1]
+    if attr[:1] == attr[-1:] == '*':
+        result.append(codes['bold'])
+        attr = attr[1:-1]
+    if attr[:1] == attr[-1:] == '_':
+        result.append(codes['underline'])
+        attr = attr[1:-1]
+    result.append(codes[attr])
+    result.append(text)
+    result.append(codes['reset'])
+    return ''.join(result)

env/kimodo/lib/python3.10/site-packages/pygments/filter.py

@@ -0,0 +1,70 @@
+"""
+    pygments.filter
+    ~~~~~~~~~~~~~~~
+
+    Module that implements the default filter.
+
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+
+def apply_filters(stream, filters, lexer=None):
+    """
+    Use this method to apply an iterable of filters to
+    a stream. If lexer is given it's forwarded to the
+    filter, otherwise the filter receives `None`.
+    """
+    def _apply(filter_, stream):
+        yield from filter_.filter(lexer, stream)
+    for filter_ in filters:
+        stream = _apply(filter_, stream)
+    return stream
+
+
+def simplefilter(f):
+    """
+    Decorator that converts a function into a filter::
+
+        @simplefilter
+        def lowercase(self, lexer, stream, options):
+            for ttype, value in stream:
+                yield ttype, value.lower()
+    """
+    return type(f.__name__, (FunctionFilter,), {
+        '__module__': getattr(f, '__module__'),
+        '__doc__': f.__doc__,
+        'function': f,
+    })
+
+
+class Filter:
+    """
+    Default filter. Subclass this class or use the `simplefilter`
+    decorator to create own filters.
+    """
+
+    def __init__(self, **options):
+        self.options = options
+
+    def filter(self, lexer, stream):
+        raise NotImplementedError()
+
+
+class FunctionFilter(Filter):
+    """
+    Abstract class used by `simplefilter` to create simple
+    function filters on the fly. The `simplefilter` decorator
+    automatically creates subclasses of this class for
+    functions passed to it.
+    """
+    function = None
+
+    def __init__(self, **options):
+        if not hasattr(self, 'function'):
+            raise TypeError(f'{self.__class__.__name__!r} used without bound function')
+        Filter.__init__(self, **options)
+
+    def filter(self, lexer, stream):
+        # pylint: disable=not-callable
+        yield from self.function(lexer, stream, self.options)

env/kimodo/lib/python3.10/site-packages/pygments/filters/__init__.py

@@ -0,0 +1,940 @@
+"""
+    pygments.filters
+    ~~~~~~~~~~~~~~~~
+
+    Module containing filter lookup functions and default
+    filters.
+
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.token import String, Comment, Keyword, Name, Error, Whitespace, \
+    string_to_tokentype
+from pygments.filter import Filter
+from pygments.util import get_list_opt, get_int_opt, get_bool_opt, \
+    get_choice_opt, ClassNotFound, OptionError
+from pygments.plugin import find_plugin_filters
+
+
+def find_filter_class(filtername):
+    """Lookup a filter by name. Return None if not found."""
+    if filtername in FILTERS:
+        return FILTERS[filtername]
+    for name, cls in find_plugin_filters():
+        if name == filtername:
+            return cls
+    return None
+
+
+def get_filter_by_name(filtername, **options):
+    """Return an instantiated filter.
+
+    Options are passed to the filter initializer if wanted.
+    Raise a ClassNotFound if not found.
+    """
+    cls = find_filter_class(filtername)
+    if cls:
+        return cls(**options)
+    else:
+        raise ClassNotFound(f'filter {filtername!r} not found')
+
+
+def get_all_filters():
+    """Return a generator of all filter names."""
+    yield from FILTERS
+    for name, _ in find_plugin_filters():
+        yield name
+
+
+def _replace_special(ttype, value, regex, specialttype,
+                     replacefunc=lambda x: x):
+    last = 0
+    for match in regex.finditer(value):
+        start, end = match.start(), match.end()
+        if start != last:
+            yield ttype, value[last:start]
+        yield specialttype, replacefunc(value[start:end])
+        last = end
+    if last != len(value):
+        yield ttype, value[last:]
+
+
+class CodeTagFilter(Filter):
+    """Highlight special code tags in comments and docstrings.
+
+    Options accepted:
+
+    `codetags` : list of strings
+       A list of strings that are flagged as code tags.  The default is to
+       highlight ``XXX``, ``TODO``, ``FIXME``, ``BUG`` and ``NOTE``.
+
+    .. versionchanged:: 2.13
+       Now recognizes ``FIXME`` by default.
+    """
+
+    def __init__(self, **options):
+        Filter.__init__(self, **options)
+        tags = get_list_opt(options, 'codetags',
+                            ['XXX', 'TODO', 'FIXME', 'BUG', 'NOTE'])
+        self.tag_re = re.compile(r'\b({})\b'.format('|'.join([
+            re.escape(tag) for tag in tags if tag
+        ])))
+
+    def filter(self, lexer, stream):
+        regex = self.tag_re
+        for ttype, value in stream:
+            if ttype in String.Doc or \
+               ttype in Comment and \
+               ttype not in Comment.Preproc:
+                yield from _replace_special(ttype, value, regex, Comment.Special)
+            else:
+                yield ttype, value
+
+
+class SymbolFilter(Filter):
+    """Convert mathematical symbols such as \\<longrightarrow> in Isabelle
+    or \\longrightarrow in LaTeX into Unicode characters.
+
+    This is mostly useful for HTML or console output when you want to
+    approximate the source rendering you'd see in an IDE.
+
+    Options accepted:
+
+    `lang` : string
+       The symbol language. Must be one of ``'isabelle'`` or
+       ``'latex'``.  The default is ``'isabelle'``.
+    """
+
+    latex_symbols = {
+        '\\alpha'                : '\U000003b1',
+        '\\beta'                 : '\U000003b2',
+        '\\gamma'                : '\U000003b3',
+        '\\delta'                : '\U000003b4',
+        '\\varepsilon'           : '\U000003b5',
+        '\\zeta'                 : '\U000003b6',
+        '\\eta'                  : '\U000003b7',
+        '\\vartheta'             : '\U000003b8',
+        '\\iota'                 : '\U000003b9',
+        '\\kappa'                : '\U000003ba',
+        '\\lambda'               : '\U000003bb',
+        '\\mu'                   : '\U000003bc',
+        '\\nu'                   : '\U000003bd',
+        '\\xi'                   : '\U000003be',
+        '\\pi'                   : '\U000003c0',
+        '\\varrho'               : '\U000003c1',
+        '\\sigma'                : '\U000003c3',
+        '\\tau'                  : '\U000003c4',
+        '\\upsilon'              : '\U000003c5',
+        '\\varphi'               : '\U000003c6',
+        '\\chi'                  : '\U000003c7',
+        '\\psi'                  : '\U000003c8',
+        '\\omega'                : '\U000003c9',
+        '\\Gamma'                : '\U00000393',
+        '\\Delta'                : '\U00000394',
+        '\\Theta'                : '\U00000398',
+        '\\Lambda'               : '\U0000039b',
+        '\\Xi'                   : '\U0000039e',
+        '\\Pi'                   : '\U000003a0',
+        '\\Sigma'                : '\U000003a3',
+        '\\Upsilon'              : '\U000003a5',
+        '\\Phi'                  : '\U000003a6',
+        '\\Psi'                  : '\U000003a8',
+        '\\Omega'                : '\U000003a9',
+        '\\leftarrow'            : '\U00002190',
+        '\\longleftarrow'        : '\U000027f5',
+        '\\rightarrow'           : '\U00002192',
+        '\\longrightarrow'       : '\U000027f6',
+        '\\Leftarrow'            : '\U000021d0',
+        '\\Longleftarrow'        : '\U000027f8',
+        '\\Rightarrow'           : '\U000021d2',
+        '\\Longrightarrow'       : '\U000027f9',
+        '\\leftrightarrow'       : '\U00002194',
+        '\\longleftrightarrow'   : '\U000027f7',
+        '\\Leftrightarrow'       : '\U000021d4',
+        '\\Longleftrightarrow'   : '\U000027fa',
+        '\\mapsto'               : '\U000021a6',
+        '\\longmapsto'           : '\U000027fc',
+        '\\relbar'               : '\U00002500',
+        '\\Relbar'               : '\U00002550',
+        '\\hookleftarrow'        : '\U000021a9',
+        '\\hookrightarrow'       : '\U000021aa',
+        '\\leftharpoondown'      : '\U000021bd',
+        '\\rightharpoondown'     : '\U000021c1',
+        '\\leftharpoonup'        : '\U000021bc',
+        '\\rightharpoonup'       : '\U000021c0',
+        '\\rightleftharpoons'    : '\U000021cc',
+        '\\leadsto'              : '\U0000219d',
+        '\\downharpoonleft'      : '\U000021c3',
+        '\\downharpoonright'     : '\U000021c2',
+        '\\upharpoonleft'        : '\U000021bf',
+        '\\upharpoonright'       : '\U000021be',
+        '\\restriction'          : '\U000021be',
+        '\\uparrow'              : '\U00002191',
+        '\\Uparrow'              : '\U000021d1',
+        '\\downarrow'            : '\U00002193',
+        '\\Downarrow'            : '\U000021d3',
+        '\\updownarrow'          : '\U00002195',
+        '\\Updownarrow'          : '\U000021d5',
+        '\\langle'               : '\U000027e8',
+        '\\rangle'               : '\U000027e9',
+        '\\lceil'                : '\U00002308',
+        '\\rceil'                : '\U00002309',
+        '\\lfloor'               : '\U0000230a',
+        '\\rfloor'               : '\U0000230b',
+        '\\flqq'                 : '\U000000ab',
+        '\\frqq'                 : '\U000000bb',
+        '\\bot'                  : '\U000022a5',
+        '\\top'                  : '\U000022a4',
+        '\\wedge'                : '\U00002227',
+        '\\bigwedge'             : '\U000022c0',
+        '\\vee'                  : '\U00002228',
+        '\\bigvee'               : '\U000022c1',
+        '\\forall'               : '\U00002200',
+        '\\exists'               : '\U00002203',
+        '\\nexists'              : '\U00002204',
+        '\\neg'                  : '\U000000ac',
+        '\\Box'                  : '\U000025a1',
+        '\\Diamond'              : '\U000025c7',
+        '\\vdash'                : '\U000022a2',
+        '\\models'               : '\U000022a8',
+        '\\dashv'                : '\U000022a3',
+        '\\surd'                 : '\U0000221a',
+        '\\le'                   : '\U00002264',
+        '\\ge'                   : '\U00002265',
+        '\\ll'                   : '\U0000226a',
+        '\\gg'                   : '\U0000226b',
+        '\\lesssim'              : '\U00002272',
+        '\\gtrsim'               : '\U00002273',
+        '\\lessapprox'           : '\U00002a85',
+        '\\gtrapprox'            : '\U00002a86',
+        '\\in'                   : '\U00002208',
+        '\\notin'                : '\U00002209',
+        '\\subset'               : '\U00002282',
+        '\\supset'               : '\U00002283',
+        '\\subseteq'             : '\U00002286',
+        '\\supseteq'             : '\U00002287',
+        '\\sqsubset'             : '\U0000228f',
+        '\\sqsupset'             : '\U00002290',
+        '\\sqsubseteq'           : '\U00002291',
+        '\\sqsupseteq'           : '\U00002292',
+        '\\cap'                  : '\U00002229',
+        '\\bigcap'               : '\U000022c2',
+        '\\cup'                  : '\U0000222a',
+        '\\bigcup'               : '\U000022c3',
+        '\\sqcup'                : '\U00002294',
+        '\\bigsqcup'             : '\U00002a06',
+        '\\sqcap'                : '\U00002293',
+        '\\Bigsqcap'             : '\U00002a05',
+        '\\setminus'             : '\U00002216',
+        '\\propto'               : '\U0000221d',
+        '\\uplus'                : '\U0000228e',
+        '\\bigplus'              : '\U00002a04',
+        '\\sim'                  : '\U0000223c',
+        '\\doteq'                : '\U00002250',
+        '\\simeq'                : '\U00002243',
+        '\\approx'               : '\U00002248',
+        '\\asymp'                : '\U0000224d',
+        '\\cong'                 : '\U00002245',
+        '\\equiv'                : '\U00002261',
+        '\\Join'                 : '\U000022c8',
+        '\\bowtie'               : '\U00002a1d',
+        '\\prec'                 : '\U0000227a',
+        '\\succ'                 : '\U0000227b',
+        '\\preceq'               : '\U0000227c',
+        '\\succeq'               : '\U0000227d',
+        '\\parallel'             : '\U00002225',
+        '\\mid'                  : '\U000000a6',
+        '\\pm'                   : '\U000000b1',
+        '\\mp'                   : '\U00002213',
+        '\\times'                : '\U000000d7',
+        '\\div'                  : '\U000000f7',
+        '\\cdot'                 : '\U000022c5',
+        '\\star'                 : '\U000022c6',
+        '\\circ'                 : '\U00002218',
+        '\\dagger'               : '\U00002020',
+        '\\ddagger'              : '\U00002021',
+        '\\lhd'                  : '\U000022b2',
+        '\\rhd'                  : '\U000022b3',
+        '\\unlhd'                : '\U000022b4',
+        '\\unrhd'                : '\U000022b5',
+        '\\triangleleft'         : '\U000025c3',
+        '\\triangleright'        : '\U000025b9',
+        '\\triangle'             : '\U000025b3',
+        '\\triangleq'            : '\U0000225c',
+        '\\oplus'                : '\U00002295',
+        '\\bigoplus'             : '\U00002a01',
+        '\\otimes'               : '\U00002297',
+        '\\bigotimes'            : '\U00002a02',
+        '\\odot'                 : '\U00002299',
+        '\\bigodot'              : '\U00002a00',
+        '\\ominus'               : '\U00002296',
+        '\\oslash'               : '\U00002298',
+        '\\dots'                 : '\U00002026',
+        '\\cdots'                : '\U000022ef',
+        '\\sum'                  : '\U00002211',
+        '\\prod'                 : '\U0000220f',
+        '\\coprod'               : '\U00002210',
+        '\\infty'                : '\U0000221e',
+        '\\int'                  : '\U0000222b',
+        '\\oint'                 : '\U0000222e',
+        '\\clubsuit'             : '\U00002663',
+        '\\diamondsuit'          : '\U00002662',
+        '\\heartsuit'            : '\U00002661',
+        '\\spadesuit'            : '\U00002660',
+        '\\aleph'                : '\U00002135',
+        '\\emptyset'             : '\U00002205',
+        '\\nabla'                : '\U00002207',
+        '\\partial'              : '\U00002202',
+        '\\flat'                 : '\U0000266d',
+        '\\natural'              : '\U0000266e',
+        '\\sharp'                : '\U0000266f',
+        '\\angle'                : '\U00002220',
+        '\\copyright'            : '\U000000a9',
+        '\\textregistered'       : '\U000000ae',
+        '\\textonequarter'       : '\U000000bc',
+        '\\textonehalf'          : '\U000000bd',
+        '\\textthreequarters'    : '\U000000be',
+        '\\textordfeminine'      : '\U000000aa',
+        '\\textordmasculine'     : '\U000000ba',
+        '\\euro'                 : '\U000020ac',
+        '\\pounds'               : '\U000000a3',
+        '\\yen'                  : '\U000000a5',
+        '\\textcent'             : '\U000000a2',
+        '\\textcurrency'         : '\U000000a4',
+        '\\textdegree'           : '\U000000b0',
+    }
+
+    isabelle_symbols = {
+        '\\<zero>'                 : '\U0001d7ec',
+        '\\<one>'                  : '\U0001d7ed',
+        '\\<two>'                  : '\U0001d7ee',
+        '\\<three>'                : '\U0001d7ef',
+        '\\<four>'                 : '\U0001d7f0',
+        '\\<five>'                 : '\U0001d7f1',
+        '\\<six>'                  : '\U0001d7f2',
+        '\\<seven>'                : '\U0001d7f3',
+        '\\<eight>'                : '\U0001d7f4',
+        '\\<nine>'                 : '\U0001d7f5',
+        '\\<A>'                    : '\U0001d49c',
+        '\\<B>'                    : '\U0000212c',
+        '\\<C>'                    : '\U0001d49e',
+        '\\<D>'                    : '\U0001d49f',
+        '\\<E>'                    : '\U00002130',
+        '\\<F>'                    : '\U00002131',
+        '\\<G>'                    : '\U0001d4a2',
+        '\\<H>'                    : '\U0000210b',
+        '\\<I>'                    : '\U00002110',
+        '\\<J>'                    : '\U0001d4a5',
+        '\\<K>'                    : '\U0001d4a6',
+        '\\<L>'                    : '\U00002112',
+        '\\<M>'                    : '\U00002133',
+        '\\<N>'                    : '\U0001d4a9',
+        '\\<O>'                    : '\U0001d4aa',
+        '\\<P>'                    : '\U0001d4ab',
+        '\\<Q>'                    : '\U0001d4ac',
+        '\\<R>'                    : '\U0000211b',
+        '\\<S>'                    : '\U0001d4ae',
+        '\\<T>'                    : '\U0001d4af',
+        '\\<U>'                    : '\U0001d4b0',
+        '\\<V>'                    : '\U0001d4b1',
+        '\\<W>'                    : '\U0001d4b2',
+        '\\<X>'                    : '\U0001d4b3',
+        '\\<Y>'                    : '\U0001d4b4',
+        '\\<Z>'                    : '\U0001d4b5',
+        '\\<a>'                    : '\U0001d5ba',
+        '\\<b>'                    : '\U0001d5bb',
+        '\\<c>'                    : '\U0001d5bc',
+        '\\<d>'                    : '\U0001d5bd',
+        '\\<e>'                    : '\U0001d5be',
+        '\\<f>'                    : '\U0001d5bf',
+        '\\<g>'                    : '\U0001d5c0',
+        '\\<h>'                    : '\U0001d5c1',
+        '\\<i>'                    : '\U0001d5c2',
+        '\\<j>'                    : '\U0001d5c3',
+        '\\<k>'                    : '\U0001d5c4',
+        '\\<l>'                    : '\U0001d5c5',
+        '\\<m>'                    : '\U0001d5c6',
+        '\\<n>'                    : '\U0001d5c7',
+        '\\<o>'                    : '\U0001d5c8',
+        '\\<p>'                    : '\U0001d5c9',
+        '\\<q>'                    : '\U0001d5ca',
+        '\\<r>'                    : '\U0001d5cb',
+        '\\<s>'                    : '\U0001d5cc',
+        '\\<t>'                    : '\U0001d5cd',
+        '\\<u>'                    : '\U0001d5ce',
+        '\\<v>'                    : '\U0001d5cf',
+        '\\<w>'                    : '\U0001d5d0',
+        '\\<x>'                    : '\U0001d5d1',
+        '\\<y>'                    : '\U0001d5d2',
+        '\\<z>'                    : '\U0001d5d3',
+        '\\<AA>'                   : '\U0001d504',
+        '\\<BB>'                   : '\U0001d505',
+        '\\<CC>'                   : '\U0000212d',
+        '\\<DD>'                   : '\U0001d507',
+        '\\<EE>'                   : '\U0001d508',
+        '\\<FF>'                   : '\U0001d509',
+        '\\<GG>'                   : '\U0001d50a',
+        '\\<HH>'                   : '\U0000210c',
+        '\\<II>'                   : '\U00002111',
+        '\\<JJ>'                   : '\U0001d50d',
+        '\\<KK>'                   : '\U0001d50e',
+        '\\<LL>'                   : '\U0001d50f',
+        '\\<MM>'                   : '\U0001d510',
+        '\\<NN>'                   : '\U0001d511',
+        '\\<OO>'                   : '\U0001d512',
+        '\\<PP>'                   : '\U0001d513',
+        '\\<QQ>'                   : '\U0001d514',
+        '\\<RR>'                   : '\U0000211c',
+        '\\<SS>'                   : '\U0001d516',
+        '\\<TT>'                   : '\U0001d517',
+        '\\<UU>'                   : '\U0001d518',
+        '\\<VV>'                   : '\U0001d519',
+        '\\<WW>'                   : '\U0001d51a',
+        '\\<XX>'                   : '\U0001d51b',
+        '\\<YY>'                   : '\U0001d51c',
+        '\\<ZZ>'                   : '\U00002128',
+        '\\<aa>'                   : '\U0001d51e',
+        '\\<bb>'                   : '\U0001d51f',
+        '\\<cc>'                   : '\U0001d520',
+        '\\<dd>'                   : '\U0001d521',
+        '\\<ee>'                   : '\U0001d522',
+        '\\<ff>'                   : '\U0001d523',
+        '\\<gg>'                   : '\U0001d524',
+        '\\<hh>'                   : '\U0001d525',
+        '\\<ii>'                   : '\U0001d526',
+        '\\<jj>'                   : '\U0001d527',
+        '\\<kk>'                   : '\U0001d528',
+        '\\<ll>'                   : '\U0001d529',
+        '\\<mm>'                   : '\U0001d52a',
+        '\\<nn>'                   : '\U0001d52b',
+        '\\<oo>'                   : '\U0001d52c',
+        '\\<pp>'                   : '\U0001d52d',
+        '\\<qq>'                   : '\U0001d52e',
+        '\\<rr>'                   : '\U0001d52f',
+        '\\<ss>'                   : '\U0001d530',
+        '\\<tt>'                   : '\U0001d531',
+        '\\<uu>'                   : '\U0001d532',
+        '\\<vv>'                   : '\U0001d533',
+        '\\<ww>'                   : '\U0001d534',
+        '\\<xx>'                   : '\U0001d535',
+        '\\<yy>'                   : '\U0001d536',
+        '\\<zz>'                   : '\U0001d537',
+        '\\<alpha>'                : '\U000003b1',
+        '\\<beta>'                 : '\U000003b2',
+        '\\<gamma>'                : '\U000003b3',
+        '\\<delta>'                : '\U000003b4',
+        '\\<epsilon>'              : '\U000003b5',
+        '\\<zeta>'                 : '\U000003b6',
+        '\\<eta>'                  : '\U000003b7',
+        '\\<theta>'                : '\U000003b8',
+        '\\<iota>'                 : '\U000003b9',
+        '\\<kappa>'                : '\U000003ba',
+        '\\<lambda>'               : '\U000003bb',
+        '\\<mu>'                   : '\U000003bc',
+        '\\<nu>'                   : '\U000003bd',
+        '\\<xi>'                   : '\U000003be',
+        '\\<pi>'                   : '\U000003c0',
+        '\\<rho>'                  : '\U000003c1',
+        '\\<sigma>'                : '\U000003c3',
+        '\\<tau>'                  : '\U000003c4',
+        '\\<upsilon>'              : '\U000003c5',
+        '\\<phi>'                  : '\U000003c6',
+        '\\<chi>'                  : '\U000003c7',
+        '\\<psi>'                  : '\U000003c8',
+        '\\<omega>'                : '\U000003c9',
+        '\\<Gamma>'                : '\U00000393',
+        '\\<Delta>'                : '\U00000394',
+        '\\<Theta>'                : '\U00000398',
+        '\\<Lambda>'               : '\U0000039b',
+        '\\<Xi>'                   : '\U0000039e',
+        '\\<Pi>'                   : '\U000003a0',
+        '\\<Sigma>'                : '\U000003a3',
+        '\\<Upsilon>'              : '\U000003a5',
+        '\\<Phi>'                  : '\U000003a6',
+        '\\<Psi>'                  : '\U000003a8',
+        '\\<Omega>'                : '\U000003a9',
+        '\\<bool>'                 : '\U0001d539',
+        '\\<complex>'              : '\U00002102',
+        '\\<nat>'                  : '\U00002115',
+        '\\<rat>'                  : '\U0000211a',
+        '\\<real>'                 : '\U0000211d',
+        '\\<int>'                  : '\U00002124',
+        '\\<leftarrow>'            : '\U00002190',
+        '\\<longleftarrow>'        : '\U000027f5',
+        '\\<rightarrow>'           : '\U00002192',
+        '\\<longrightarrow>'       : '\U000027f6',
+        '\\<Leftarrow>'            : '\U000021d0',
+        '\\<Longleftarrow>'        : '\U000027f8',
+        '\\<Rightarrow>'           : '\U000021d2',
+        '\\<Longrightarrow>'       : '\U000027f9',
+        '\\<leftrightarrow>'       : '\U00002194',
+        '\\<longleftrightarrow>'   : '\U000027f7',
+        '\\<Leftrightarrow>'       : '\U000021d4',
+        '\\<Longleftrightarrow>'   : '\U000027fa',
+        '\\<mapsto>'               : '\U000021a6',
+        '\\<longmapsto>'           : '\U000027fc',
+        '\\<midarrow>'             : '\U00002500',
+        '\\<Midarrow>'             : '\U00002550',
+        '\\<hookleftarrow>'        : '\U000021a9',
+        '\\<hookrightarrow>'       : '\U000021aa',
+        '\\<leftharpoondown>'      : '\U000021bd',
+        '\\<rightharpoondown>'     : '\U000021c1',
+        '\\<leftharpoonup>'        : '\U000021bc',
+        '\\<rightharpoonup>'       : '\U000021c0',
+        '\\<rightleftharpoons>'    : '\U000021cc',
+        '\\<leadsto>'              : '\U0000219d',
+        '\\<downharpoonleft>'      : '\U000021c3',
+        '\\<downharpoonright>'     : '\U000021c2',
+        '\\<upharpoonleft>'        : '\U000021bf',
+        '\\<upharpoonright>'       : '\U000021be',
+        '\\<restriction>'          : '\U000021be',
+        '\\<Colon>'                : '\U00002237',
+        '\\<up>'                   : '\U00002191',
+        '\\<Up>'                   : '\U000021d1',
+        '\\<down>'                 : '\U00002193',
+        '\\<Down>'                 : '\U000021d3',
+        '\\<updown>'               : '\U00002195',
+        '\\<Updown>'               : '\U000021d5',
+        '\\<langle>'               : '\U000027e8',
+        '\\<rangle>'               : '\U000027e9',
+        '\\<lceil>'                : '\U00002308',
+        '\\<rceil>'                : '\U00002309',
+        '\\<lfloor>'               : '\U0000230a',
+        '\\<rfloor>'               : '\U0000230b',
+        '\\<lparr>'                : '\U00002987',
+        '\\<rparr>'                : '\U00002988',
+        '\\<lbrakk>'               : '\U000027e6',
+        '\\<rbrakk>'               : '\U000027e7',
+        '\\<lbrace>'               : '\U00002983',
+        '\\<rbrace>'               : '\U00002984',
+        '\\<guillemotleft>'        : '\U000000ab',
+        '\\<guillemotright>'       : '\U000000bb',
+        '\\<bottom>'               : '\U000022a5',
+        '\\<top>'                  : '\U000022a4',
+        '\\<and>'                  : '\U00002227',
+        '\\<And>'                  : '\U000022c0',
+        '\\<or>'                   : '\U00002228',
+        '\\<Or>'                   : '\U000022c1',
+        '\\<forall>'               : '\U00002200',
+        '\\<exists>'               : '\U00002203',
+        '\\<nexists>'              : '\U00002204',
+        '\\<not>'                  : '\U000000ac',
+        '\\<box>'                  : '\U000025a1',
+        '\\<diamond>'              : '\U000025c7',
+        '\\<turnstile>'            : '\U000022a2',
+        '\\<Turnstile>'            : '\U000022a8',
+        '\\<tturnstile>'           : '\U000022a9',
+        '\\<TTurnstile>'           : '\U000022ab',
+        '\\<stileturn>'            : '\U000022a3',
+        '\\<surd>'                 : '\U0000221a',
+        '\\<le>'                   : '\U00002264',
+        '\\<ge>'                   : '\U00002265',
+        '\\<lless>'                : '\U0000226a',
+        '\\<ggreater>'             : '\U0000226b',
+        '\\<lesssim>'              : '\U00002272',
+        '\\<greatersim>'           : '\U00002273',
+        '\\<lessapprox>'           : '\U00002a85',
+        '\\<greaterapprox>'        : '\U00002a86',
+        '\\<in>'                   : '\U00002208',
+        '\\<notin>'                : '\U00002209',
+        '\\<subset>'               : '\U00002282',
+        '\\<supset>'               : '\U00002283',
+        '\\<subseteq>'             : '\U00002286',
+        '\\<supseteq>'             : '\U00002287',
+        '\\<sqsubset>'             : '\U0000228f',
+        '\\<sqsupset>'             : '\U00002290',
+        '\\<sqsubseteq>'           : '\U00002291',
+        '\\<sqsupseteq>'           : '\U00002292',
+        '\\<inter>'                : '\U00002229',
+        '\\<Inter>'                : '\U000022c2',
+        '\\<union>'                : '\U0000222a',
+        '\\<Union>'                : '\U000022c3',
+        '\\<squnion>'              : '\U00002294',
+        '\\<Squnion>'              : '\U00002a06',
+        '\\<sqinter>'              : '\U00002293',
+        '\\<Sqinter>'              : '\U00002a05',
+        '\\<setminus>'             : '\U00002216',
+        '\\<propto>'               : '\U0000221d',
+        '\\<uplus>'                : '\U0000228e',
+        '\\<Uplus>'                : '\U00002a04',
+        '\\<noteq>'                : '\U00002260',
+        '\\<sim>'                  : '\U0000223c',
+        '\\<doteq>'                : '\U00002250',
+        '\\<simeq>'                : '\U00002243',
+        '\\<approx>'               : '\U00002248',
+        '\\<asymp>'                : '\U0000224d',
+        '\\<cong>'                 : '\U00002245',
+        '\\<smile>'                : '\U00002323',
+        '\\<equiv>'                : '\U00002261',
+        '\\<frown>'                : '\U00002322',
+        '\\<Join>'                 : '\U000022c8',
+        '\\<bowtie>'               : '\U00002a1d',
+        '\\<prec>'                 : '\U0000227a',
+        '\\<succ>'                 : '\U0000227b',
+        '\\<preceq>'               : '\U0000227c',
+        '\\<succeq>'               : '\U0000227d',
+        '\\<parallel>'             : '\U00002225',
+        '\\<bar>'                  : '\U000000a6',
+        '\\<plusminus>'            : '\U000000b1',
+        '\\<minusplus>'            : '\U00002213',
+        '\\<times>'                : '\U000000d7',
+        '\\<div>'                  : '\U000000f7',
+        '\\<cdot>'                 : '\U000022c5',
+        '\\<star>'                 : '\U000022c6',
+        '\\<bullet>'               : '\U00002219',
+        '\\<circ>'                 : '\U00002218',
+        '\\<dagger>'               : '\U00002020',
+        '\\<ddagger>'              : '\U00002021',
+        '\\<lhd>'                  : '\U000022b2',
+        '\\<rhd>'                  : '\U000022b3',
+        '\\<unlhd>'                : '\U000022b4',
+        '\\<unrhd>'                : '\U000022b5',
+        '\\<triangleleft>'         : '\U000025c3',
+        '\\<triangleright>'        : '\U000025b9',
+        '\\<triangle>'             : '\U000025b3',
+        '\\<triangleq>'            : '\U0000225c',
+        '\\<oplus>'                : '\U00002295',
+        '\\<Oplus>'                : '\U00002a01',
+        '\\<otimes>'               : '\U00002297',
+        '\\<Otimes>'               : '\U00002a02',
+        '\\<odot>'                 : '\U00002299',
+        '\\<Odot>'                 : '\U00002a00',
+        '\\<ominus>'               : '\U00002296',
+        '\\<oslash>'               : '\U00002298',
+        '\\<dots>'                 : '\U00002026',
+        '\\<cdots>'                : '\U000022ef',
+        '\\<Sum>'                  : '\U00002211',
+        '\\<Prod>'                 : '\U0000220f',
+        '\\<Coprod>'               : '\U00002210',
+        '\\<infinity>'             : '\U0000221e',
+        '\\<integral>'             : '\U0000222b',
+        '\\<ointegral>'            : '\U0000222e',
+        '\\<clubsuit>'             : '\U00002663',
+        '\\<diamondsuit>'          : '\U00002662',
+        '\\<heartsuit>'            : '\U00002661',
+        '\\<spadesuit>'            : '\U00002660',
+        '\\<aleph>'                : '\U00002135',
+        '\\<emptyset>'             : '\U00002205',
+        '\\<nabla>'                : '\U00002207',
+        '\\<partial>'              : '\U00002202',
+        '\\<flat>'                 : '\U0000266d',
+        '\\<natural>'              : '\U0000266e',
+        '\\<sharp>'                : '\U0000266f',
+        '\\<angle>'                : '\U00002220',
+        '\\<copyright>'            : '\U000000a9',
+        '\\<registered>'           : '\U000000ae',
+        '\\<hyphen>'               : '\U000000ad',
+        '\\<inverse>'              : '\U000000af',
+        '\\<onequarter>'           : '\U000000bc',
+        '\\<onehalf>'              : '\U000000bd',
+        '\\<threequarters>'        : '\U000000be',
+        '\\<ordfeminine>'          : '\U000000aa',
+        '\\<ordmasculine>'         : '\U000000ba',
+        '\\<section>'              : '\U000000a7',
+        '\\<paragraph>'            : '\U000000b6',
+        '\\<exclamdown>'           : '\U000000a1',
+        '\\<questiondown>'         : '\U000000bf',
+        '\\<euro>'                 : '\U000020ac',
+        '\\<pounds>'               : '\U000000a3',
+        '\\<yen>'                  : '\U000000a5',
+        '\\<cent>'                 : '\U000000a2',
+        '\\<currency>'             : '\U000000a4',
+        '\\<degree>'               : '\U000000b0',
+        '\\<amalg>'                : '\U00002a3f',
+        '\\<mho>'                  : '\U00002127',
+        '\\<lozenge>'              : '\U000025ca',
+        '\\<wp>'                   : '\U00002118',
+        '\\<wrong>'                : '\U00002240',
+        '\\<struct>'               : '\U000022c4',
+        '\\<acute>'                : '\U000000b4',
+        '\\<index>'                : '\U00000131',
+        '\\<dieresis>'             : '\U000000a8',
+        '\\<cedilla>'              : '\U000000b8',
+        '\\<hungarumlaut>'         : '\U000002dd',
+        '\\<some>'                 : '\U000003f5',
+        '\\<newline>'              : '\U000023ce',
+        '\\<open>'                 : '\U00002039',
+        '\\<close>'                : '\U0000203a',
+        '\\<here>'                 : '\U00002302',
+        '\\<^sub>'                 : '\U000021e9',
+        '\\<^sup>'                 : '\U000021e7',
+        '\\<^bold>'                : '\U00002759',
+        '\\<^bsub>'                : '\U000021d8',
+        '\\<^esub>'                : '\U000021d9',
+        '\\<^bsup>'                : '\U000021d7',
+        '\\<^esup>'                : '\U000021d6',
+    }
+
+    lang_map = {'isabelle' : isabelle_symbols, 'latex' : latex_symbols}
+
+    def __init__(self, **options):
+        Filter.__init__(self, **options)
+        lang = get_choice_opt(options, 'lang',
+                              ['isabelle', 'latex'], 'isabelle')
+        self.symbols = self.lang_map[lang]
+
+    def filter(self, lexer, stream):
+        for ttype, value in stream:
+            if value in self.symbols:
+                yield ttype, self.symbols[value]
+            else:
+                yield ttype, value
+
+
+class KeywordCaseFilter(Filter):
+    """Convert keywords to lowercase or uppercase or capitalize them, which
+    means first letter uppercase, rest lowercase.
+
+    This can be useful e.g. if you highlight Pascal code and want to adapt the
+    code to your styleguide.
+
+    Options accepted:
+
+    `case` : string
+       The casing to convert keywords to. Must be one of ``'lower'``,
+       ``'upper'`` or ``'capitalize'``.  The default is ``'lower'``.
+    """
+
+    def __init__(self, **options):
+        Filter.__init__(self, **options)
+        case = get_choice_opt(options, 'case',
+                              ['lower', 'upper', 'capitalize'], 'lower')
+        self.convert = getattr(str, case)
+
+    def filter(self, lexer, stream):
+        for ttype, value in stream:
+            if ttype in Keyword:
+                yield ttype, self.convert(value)
+            else:
+                yield ttype, value
+
+
+class NameHighlightFilter(Filter):
+    """Highlight a normal Name (and Name.*) token with a different token type.
+
+    Example::
+
+        filter = NameHighlightFilter(
+            names=['foo', 'bar', 'baz'],
+            tokentype=Name.Function,
+        )
+
+    This would highlight the names "foo", "bar" and "baz"
+    as functions. `Name.Function` is the default token type.
+
+    Options accepted:
+
+    `names` : list of strings
+      A list of names that should be given the different token type.
+      There is no default.
+    `tokentype` : TokenType or string
+      A token type or a string containing a token type name that is
+      used for highlighting the strings in `names`.  The default is
+      `Name.Function`.
+    """
+
+    def __init__(self, **options):
+        Filter.__init__(self, **options)
+        self.names = set(get_list_opt(options, 'names', []))
+        tokentype = options.get('tokentype')
+        if tokentype:
+            self.tokentype = string_to_tokentype(tokentype)
+        else:
+            self.tokentype = Name.Function
+
+    def filter(self, lexer, stream):
+        for ttype, value in stream:
+            if ttype in Name and value in self.names:
+                yield self.tokentype, value
+            else:
+                yield ttype, value
+
+
+class ErrorToken(Exception):
+    pass
+
+
+class RaiseOnErrorTokenFilter(Filter):
+    """Raise an exception when the lexer generates an error token.
+
+    Options accepted:
+
+    `excclass` : Exception class
+      The exception class to raise.
+      The default is `pygments.filters.ErrorToken`.
+
+    .. versionadded:: 0.8
+    """
+
+    def __init__(self, **options):
+        Filter.__init__(self, **options)
+        self.exception = options.get('excclass', ErrorToken)
+        try:
+            # issubclass() will raise TypeError if first argument is not a class
+            if not issubclass(self.exception, Exception):
+                raise TypeError
+        except TypeError:
+            raise OptionError('excclass option is not an exception class')
+
+    def filter(self, lexer, stream):
+        for ttype, value in stream:
+            if ttype is Error:
+                raise self.exception(value)
+            yield ttype, value
+
+
+class VisibleWhitespaceFilter(Filter):
+    """Convert tabs, newlines and/or spaces to visible characters.
+
+    Options accepted:
+
+    `spaces` : string or bool
+      If this is a one-character string, spaces will be replaces by this string.
+      If it is another true value, spaces will be replaced by ``·`` (unicode
+      MIDDLE DOT).  If it is a false value, spaces will not be replaced.  The
+      default is ``False``.
+    `tabs` : string or bool
+      The same as for `spaces`, but the default replacement character is ``»``
+      (unicode RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK).  The default value
+      is ``False``.  Note: this will not work if the `tabsize` option for the
+      lexer is nonzero, as tabs will already have been expanded then.
+    `tabsize` : int
+      If tabs are to be replaced by this filter (see the `tabs` option), this
+      is the total number of characters that a tab should be expanded to.
+      The default is ``8``.
+    `newlines` : string or bool
+      The same as for `spaces`, but the default replacement character is ``¶``
+      (unicode PILCROW SIGN).  The default value is ``False``.
+    `wstokentype` : bool
+      If true, give whitespace the special `Whitespace` token type.  This allows
+      styling the visible whitespace differently (e.g. greyed out), but it can
+      disrupt background colors.  The default is ``True``.
+
+    .. versionadded:: 0.8
+    """
+
+    def __init__(self, **options):
+        Filter.__init__(self, **options)
+        for name, default in [('spaces',   '·'),
+                              ('tabs',     '»'),
+                              ('newlines', '¶')]:
+            opt = options.get(name, False)
+            if isinstance(opt, str) and len(opt) == 1:
+                setattr(self, name, opt)
+            else:
+                setattr(self, name, (opt and default or ''))
+        tabsize = get_int_opt(options, 'tabsize', 8)
+        if self.tabs:
+            self.tabs += ' ' * (tabsize - 1)
+        if self.newlines:
+            self.newlines += '\n'
+        self.wstt = get_bool_opt(options, 'wstokentype', True)
+
+    def filter(self, lexer, stream):
+        if self.wstt:
+            spaces = self.spaces or ' '
+            tabs = self.tabs or '\t'
+            newlines = self.newlines or '\n'
+            regex = re.compile(r'\s')
+
+            def replacefunc(wschar):
+                if wschar == ' ':
+                    return spaces
+                elif wschar == '\t':
+                    return tabs
+                elif wschar == '\n':
+                    return newlines
+                return wschar
+
+            for ttype, value in stream:
+                yield from _replace_special(ttype, value, regex, Whitespace,
+                                            replacefunc)
+        else:
+            spaces, tabs, newlines = self.spaces, self.tabs, self.newlines
+            # simpler processing
+            for ttype, value in stream:
+                if spaces:
+                    value = value.replace(' ', spaces)
+                if tabs:
+                    value = value.replace('\t', tabs)
+                if newlines:
+                    value = value.replace('\n', newlines)
+                yield ttype, value
+
+
+class GobbleFilter(Filter):
+    """Gobbles source code lines (eats initial characters).
+
+    This filter drops the first ``n`` characters off every line of code.  This
+    may be useful when the source code fed to the lexer is indented by a fixed
+    amount of space that isn't desired in the output.
+
+    Options accepted:
+
+    `n` : int
+       The number of characters to gobble.
+
+    .. versionadded:: 1.2
+    """
+    def __init__(self, **options):
+        Filter.__init__(self, **options)
+        self.n = get_int_opt(options, 'n', 0)
+
+    def gobble(self, value, left):
+        if left < len(value):
+            return value[left:], 0
+        else:
+            return '', left - len(value)
+
+    def filter(self, lexer, stream):
+        n = self.n
+        left = n  # How many characters left to gobble.
+        for ttype, value in stream:
+            # Remove ``left`` tokens from first line, ``n`` from all others.
+            parts = value.split('\n')
+            (parts[0], left) = self.gobble(parts[0], left)
+            for i in range(1, len(parts)):
+                (parts[i], left) = self.gobble(parts[i], n)
+            value = '\n'.join(parts)
+
+            if value != '':
+                yield ttype, value
+
+
+class TokenMergeFilter(Filter):
+    """Merges consecutive tokens with the same token type in the output
+    stream of a lexer.
+
+    .. versionadded:: 1.2
+    """
+    def __init__(self, **options):
+        Filter.__init__(self, **options)
+
+    def filter(self, lexer, stream):
+        current_type = None
+        current_value = None
+        for ttype, value in stream:
+            if ttype is current_type:
+                current_value += value
+            else:
+                if current_type is not None:
+                    yield current_type, current_value
+                current_type = ttype
+                current_value = value
+        if current_type is not None:
+            yield current_type, current_value
+
+
+FILTERS = {
+    'codetagify':     CodeTagFilter,
+    'keywordcase':    KeywordCaseFilter,
+    'highlight':      NameHighlightFilter,
+    'raiseonerror':   RaiseOnErrorTokenFilter,
+    'whitespace':     VisibleWhitespaceFilter,
+    'gobble':         GobbleFilter,
+    'tokenmerge':     TokenMergeFilter,
+    'symbols':        SymbolFilter,
+}

env/kimodo/lib/python3.10/site-packages/pygments/formatter.py

@@ -0,0 +1,129 @@
+"""
+    pygments.formatter
+    ~~~~~~~~~~~~~~~~~~
+
+    Base formatter class.
+
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import codecs
+
+from pygments.util import get_bool_opt
+from pygments.styles import get_style_by_name
+
+__all__ = ['Formatter']
+
+
+def _lookup_style(style):
+    if isinstance(style, str):
+        return get_style_by_name(style)
+    return style
+
+
+class Formatter:
+    """
+    Converts a token stream to text.
+
+    Formatters should have attributes to help selecting them. These
+    are similar to the corresponding :class:`~pygments.lexer.Lexer`
+    attributes.
+
+    .. autoattribute:: name
+       :no-value:
+
+    .. autoattribute:: aliases
+       :no-value:
+
+    .. autoattribute:: filenames
+       :no-value:
+
+    You can pass options as keyword arguments to the constructor.
+    All formatters accept these basic options:
+
+    ``style``
+        The style to use, can be a string or a Style subclass
+        (default: "default"). Not used by e.g. the
+        TerminalFormatter.
+    ``full``
+        Tells the formatter to output a "full" document, i.e.
+        a complete self-contained document. This doesn't have
+        any effect for some formatters (default: false).
+    ``title``
+        If ``full`` is true, the title that should be used to
+        caption the document (default: '').
+    ``encoding``
+        If given, must be an encoding name. This will be used to
+        convert the Unicode token strings to byte strings in the
+        output. If it is "" or None, Unicode strings will be written
+        to the output file, which most file-like objects do not
+        support (default: None).
+    ``outencoding``
+        Overrides ``encoding`` if given.
+
+    """
+
+    #: Full name for the formatter, in human-readable form.
+    name = None
+
+    #: A list of short, unique identifiers that can be used to lookup
+    #: the formatter from a list, e.g. using :func:`.get_formatter_by_name()`.
+    aliases = []
+
+    #: A list of fnmatch patterns that match filenames for which this
+    #: formatter can produce output. The patterns in this list should be unique
+    #: among all formatters.
+    filenames = []
+
+    #: If True, this formatter outputs Unicode strings when no encoding
+    #: option is given.
+    unicodeoutput = True
+
+    def __init__(self, **options):
+        """
+        As with lexers, this constructor takes arbitrary optional arguments,
+        and if you override it, you should first process your own options, then
+        call the base class implementation.
+        """
+        self.style = _lookup_style(options.get('style', 'default'))
+        self.full = get_bool_opt(options, 'full', False)
+        self.title = options.get('title', '')
+        self.encoding = options.get('encoding', None) or None
+        if self.encoding in ('guess', 'chardet'):
+            # can happen for e.g. pygmentize -O encoding=guess
+            self.encoding = 'utf-8'
+        self.encoding = options.get('outencoding') or self.encoding
+        self.options = options
+
+    def get_style_defs(self, arg=''):
+        """
+        This method must return statements or declarations suitable to define
+        the current style for subsequent highlighted text (e.g. CSS classes
+        in the `HTMLFormatter`).
+
+        The optional argument `arg` can be used to modify the generation and
+        is formatter dependent (it is standardized because it can be given on
+        the command line).
+
+        This method is called by the ``-S`` :doc:`command-line option <cmdline>`,
+        the `arg` is then given by the ``-a`` option.
+        """
+        return ''
+
+    def format(self, tokensource, outfile):
+        """
+        This method must format the tokens from the `tokensource` iterable and
+        write the formatted version to the file object `outfile`.
+
+        Formatter options can control how exactly the tokens are converted.
+        """
+        if self.encoding:
+            # wrap the outfile in a StreamWriter
+            outfile = codecs.lookup(self.encoding)[3](outfile)
+        return self.format_unencoded(tokensource, outfile)
+
+    # Allow writing Formatter[str] or Formatter[bytes]. That's equivalent to
+    # Formatter. This helps when using third-party type stubs from typeshed.
+    def __class_getitem__(cls, name):
+        return cls

env/kimodo/lib/python3.10/site-packages/pygments/formatters/__init__.py

@@ -0,0 +1,157 @@
+"""
+    pygments.formatters
+    ~~~~~~~~~~~~~~~~~~~
+
+    Pygments formatters.
+
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+import sys
+import types
+import fnmatch
+from os.path import basename
+
+from pygments.formatters._mapping import FORMATTERS
+from pygments.plugin import find_plugin_formatters
+from pygments.util import ClassNotFound
+
+__all__ = ['get_formatter_by_name', 'get_formatter_for_filename',
+           'get_all_formatters', 'load_formatter_from_file'] + list(FORMATTERS)
+
+_formatter_cache = {}  # classes by name
+_pattern_cache = {}
+
+
+def _fn_matches(fn, glob):
+    """Return whether the supplied file name fn matches pattern filename."""
+    if glob not in _pattern_cache:
+        pattern = _pattern_cache[glob] = re.compile(fnmatch.translate(glob))
+        return pattern.match(fn)
+    return _pattern_cache[glob].match(fn)
+
+
+def _load_formatters(module_name):
+    """Load a formatter (and all others in the module too)."""
+    mod = __import__(module_name, None, None, ['__all__'])
+    for formatter_name in mod.__all__:
+        cls = getattr(mod, formatter_name)
+        _formatter_cache[cls.name] = cls
+
+
+def get_all_formatters():
+    """Return a generator for all formatter classes."""
+    # NB: this returns formatter classes, not info like get_all_lexers().
+    for info in FORMATTERS.values():
+        if info[1] not in _formatter_cache:
+            _load_formatters(info[0])
+        yield _formatter_cache[info[1]]
+    for _, formatter in find_plugin_formatters():
+        yield formatter
+
+
+def find_formatter_class(alias):
+    """Lookup a formatter by alias.
+
+    Returns None if not found.
+    """
+    for module_name, name, aliases, _, _ in FORMATTERS.values():
+        if alias in aliases:
+            if name not in _formatter_cache:
+                _load_formatters(module_name)
+            return _formatter_cache[name]
+    for _, cls in find_plugin_formatters():
+        if alias in cls.aliases:
+            return cls
+
+
+def get_formatter_by_name(_alias, **options):
+    """
+    Return an instance of a :class:`.Formatter` subclass that has `alias` in its
+    aliases list. The formatter is given the `options` at its instantiation.
+
+    Will raise :exc:`pygments.util.ClassNotFound` if no formatter with that
+    alias is found.
+    """
+    cls = find_formatter_class(_alias)
+    if cls is None:
+        raise ClassNotFound(f"no formatter found for name {_alias!r}")
+    return cls(**options)
+
+
+def load_formatter_from_file(filename, formattername="CustomFormatter", **options):
+    """
+    Return a `Formatter` subclass instance loaded from the provided file, relative
+    to the current directory.
+
+    The file is expected to contain a Formatter class named ``formattername``
+    (by default, CustomFormatter). Users should be very careful with the input, because
+    this method is equivalent to running ``eval()`` on the input file. The formatter is
+    given the `options` at its instantiation.
+
+    :exc:`pygments.util.ClassNotFound` is raised if there are any errors loading
+    the formatter.
+
+    .. versionadded:: 2.2
+    """
+    try:
+        # This empty dict will contain the namespace for the exec'd file
+        custom_namespace = {}
+        with open(filename, 'rb') as f:
+            exec(f.read(), custom_namespace)
+        # Retrieve the class `formattername` from that namespace
+        if formattername not in custom_namespace:
+            raise ClassNotFound(f'no valid {formattername} class found in {filename}')
+        formatter_class = custom_namespace[formattername]
+        # And finally instantiate it with the options
+        return formatter_class(**options)
+    except OSError as err:
+        raise ClassNotFound(f'cannot read {filename}: {err}')
+    except ClassNotFound:
+        raise
+    except Exception as err:
+        raise ClassNotFound(f'error when loading custom formatter: {err}')
+
+
+def get_formatter_for_filename(fn, **options):
+    """
+    Return a :class:`.Formatter` subclass instance that has a filename pattern
+    matching `fn`. The formatter is given the `options` at its instantiation.
+
+    Will raise :exc:`pygments.util.ClassNotFound` if no formatter for that filename
+    is found.
+    """
+    fn = basename(fn)
+    for modname, name, _, filenames, _ in FORMATTERS.values():
+        for filename in filenames:
+            if _fn_matches(fn, filename):
+                if name not in _formatter_cache:
+                    _load_formatters(modname)
+                return _formatter_cache[name](**options)
+    for _name, cls in find_plugin_formatters():
+        for filename in cls.filenames:
+            if _fn_matches(fn, filename):
+                return cls(**options)
+    raise ClassNotFound(f"no formatter found for file name {fn!r}")
+
+
+class _automodule(types.ModuleType):
+    """Automatically import formatters."""
+
+    def __getattr__(self, name):
+        info = FORMATTERS.get(name)
+        if info:
+            _load_formatters(info[0])
+            cls = _formatter_cache[info[1]]
+            setattr(self, name, cls)
+            return cls
+        raise AttributeError(name)
+
+
+oldmod = sys.modules[__name__]
+newmod = _automodule(__name__)
+newmod.__dict__.update(oldmod.__dict__)
+sys.modules[__name__] = newmod
+del newmod.newmod, newmod.oldmod, newmod.sys, newmod.types