learning-loop-node 0.18.2__py3-none-any.whl → 0.18.3__py3-none-any.whl

{learning_loop_node-0.18.2.dist-info → learning_loop_node-0.18.3.dist-info}/METADATA

@@ -1,42 +1,40 @@
-Metadata-Version: 2.1
-Name: learning-loop-node
-Version: 0.18.2
+Metadata-Version: 2.4
+Name: learning_loop_node
+Version: 0.18.3
 Summary: Python Library for Nodes which connect to the Zauberzeug Learning Loop
-Home-page: https://github.com/zauberzeug/learning_loop_node
+Author: Zauberzeug
+Author-email: Zauberzeug GmbH <info@zauberzeug.com>
 License: MIT
-Author: Zauberzeug GmbH
-Author-email: info@zauberzeug.com
-Requires-Python: >=3.8,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Requires-Dist: Pillow (>=10.0.0,<11.0.0)
-Requires-Dist: aiofiles (>=0.7.0,<0.8.0)
-Requires-Dist: aiohttp (>=3.8.4,<4.0.0)
-Requires-Dist: async_generator (>=1.10,<2.0)
-Requires-Dist: dacite (>=1.8.1,<2.0.0)
-Requires-Dist: fastapi (>=0.93,<0.109)
-Requires-Dist: fastapi-socketio (>=0.0.10,<0.0.11)
-Requires-Dist: fastapi-utils (>=0.2.1,<0.3.0)
-Requires-Dist: httpx (>=0.28.1,<0.29.0)
-Requires-Dist: icecream (>=2.1.0,<3.0.0)
-Requires-Dist: numpy (>=1.13.3,<2.0.0)
-Requires-Dist: psutil (>=5.8.0,<6.0.0)
-Requires-Dist: pynvml (>=11.4.1,<12.0.0)
-Requires-Dist: pytest-mock (==3.6.1)
-Requires-Dist: pytest-watch (>=4.2.0,<5.0.0)
-Requires-Dist: python-multipart (>=0.0.5,<0.0.6)
-Requires-Dist: python-socketio (>=5.7.2,<6.0.0)
-Requires-Dist: requests (>=2.25.1,<3.0.0)
-Requires-Dist: simplejson (>=3.17.2,<4.0.0)
-Requires-Dist: tqdm (>=4.63.0,<5.0.0)
-Requires-Dist: uvicorn[standard] (>=0.22.0,<0.23.0)
-Requires-Dist: werkzeug (>=2.0.1,<3.0.0)
 Project-URL: Repository, https://github.com/zauberzeug/learning_loop_node
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: fastapi<1.0,>=0.128
+Requires-Dist: uvicorn[standard]<0.23.0,>=0.22.0
+Requires-Dist: fastapi-utils<0.9.0,>=0.8.0
+Requires-Dist: requests<3.0.0,>=2.25.1
+Requires-Dist: python-socketio<6.0.0,>=5.7.2
+Requires-Dist: simplejson<4.0.0,>=3.17.2
+Requires-Dist: icecream<3.0.0,>=2.1.0
+Requires-Dist: aiofiles<0.8.0,>=0.7.0
+Requires-Dist: async_generator<2.0.0,>=1.10
+Requires-Dist: pytest-watch<5.0.0,>=4.2.0
+Requires-Dist: python-multipart<0.0.19,>=0.0.18
+Requires-Dist: psutil<6.0.0,>=5.8.0
+Requires-Dist: numpy<3.0,>=2.0
+Requires-Dist: Pillow<12.0.0,>=11.0.0
+Requires-Dist: tqdm<5.0.0,>=4.66.3
+Requires-Dist: pytest-mock<4.0.0,>=3.6.1
+Requires-Dist: pynvml<12.0.0,>=11.4.1
+Requires-Dist: aiohttp<4.0.0,>=3.13.3
+Requires-Dist: httpx<0.29.0,>=0.28.1
+Requires-Dist: dacite<2.0.0,>=1.8.1
+Provides-Extra: dev
+Requires-Dist: pytest-flakefinder<2.0.0,>=1.1.0; extra == "dev"
+Requires-Dist: retry<0.10.0,>=0.9.2; extra == "dev"
+Requires-Dist: debugpy<2.0.0,>=1.6.7.post1; extra == "dev"
+Requires-Dist: pytest-asyncio<0.22.0,>=0.21.1; extra == "dev"
+Requires-Dist: autopep8<3.0.0,>=2.0.2; extra == "dev"
+Dynamic: author
 
 # Learning Loop Node
 
@@ -280,4 +278,3 @@ After a short time the converted model should be available as well.
 - Nodes add properties to `model.json`, which contains all the information which are needed by subsequent nodes. These are typically the properties:
   - `resolution`: resolution in which the model expects images (as `int`, since the resolution is mostly square - later, ` resolution_x`` resolution_y ` would also be conceivable or `resolutions` to give a list of possible resolutions)
   - `categories`: list of categories with name, id, (later also type), in the order in which they are used by the model -- this is neccessary to be robust about renamings
-

learning_loop_node-0.18.3.dist-info/RECORD

@@ -0,0 +1,11 @@
+learning_loop_node/__init__.py,sha256=onN5s8-x_xBsCM6NLmJO0Ym1sJHeCFaGw8qb0oQZmz8,364
+learning_loop_node/data_exchanger.py,sha256=nd9JNPLn9amIeTcSIyUPpbE97ORAcb5yNphvmpgWSUQ,9095
+learning_loop_node/globals.py,sha256=tgw_8RYOipPV9aYlyUhYtXfUxvJKRvfUk6u-qVAtZmY,174
+learning_loop_node/loop_communication.py,sha256=d1tJZ9T_y22FrEq1XzvidgH6d-byGxFq3ovLvPBS4FA,7611
+learning_loop_node/node.py,sha256=xK-xODRo7ov-dNNMcpLW2GAauvjKAK3K9RQh4P9S994,12160
+learning_loop_node/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+learning_loop_node/rest.py,sha256=5X9IVW9kf1gNf8jifGW9g_gI_-9TEeoMMOW16jvwpRE,1599
+learning_loop_node-0.18.3.dist-info/METADATA,sha256=fakCUdeAPgO47Y_7_CL60I54FBeYhPOv7vl_duVTQBw,15052
+learning_loop_node-0.18.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+learning_loop_node-0.18.3.dist-info/top_level.txt,sha256=nS5qiFc4stVF_VXVCVJxZnrqVOv3IGX5-_E3sLby6OE,19
+learning_loop_node-0.18.3.dist-info/RECORD,,

{learning_loop_node-0.18.2.dist-info → learning_loop_node-0.18.3.dist-info}/WHEEL

@@ -1,4 +1,5 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.6.0
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
+

learning_loop_node-0.18.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+learning_loop_node

learning_loop_node/annotation/annotator_logic.py

@@ -1,29 +0,0 @@
-from abc import abstractmethod
-from typing import Dict, Optional
-
-from ..data_classes import ToolOutput, UserInput
-from ..node import Node
-
-
-class AnnotatorLogic():
-
-    def __init__(self) -> None:
-        self._node: Optional[Node] = None
-
-    def init(self, node: Node) -> None:
-        self._node = node
-
-    @abstractmethod
-    async def handle_user_input(self, user_input: UserInput, history: Dict) -> ToolOutput:
-        """ This method is called when a user input is received from the client.
-            The function should return a ToolOutput object."""
-
-    @abstractmethod
-    def create_empty_history(self) -> Dict:
-        """ This method is called when a new annotation session is started.
-            The function should return an empty history object."""
-
-    @abstractmethod
-    def logout_user(self, sid: str) -> bool:
-        """ This method is called when a user disconnects from the server.
-            The function should return True if the user was logged out successfully."""

learning_loop_node/annotation/annotator_node.py

@@ -1,116 +0,0 @@
-from dataclasses import asdict
-from typing import Dict, Optional
-
-from dacite import from_dict
-from fastapi.encoders import jsonable_encoder
-from socketio import AsyncClient
-
-from ..data_classes import AnnotationNodeStatus, Context, NodeState, UserInput
-from ..data_classes.socket_response import SocketResponse
-from ..data_exchanger import DataExchanger
-from ..helpers.misc import create_image_folder, create_project_folder
-from ..node import Node
-from .annotator_logic import AnnotatorLogic
-
-# TODO: The use case 'segmentation' is hardcoded here. This should be more flexible.
-
-
-class AnnotatorNode(Node):
-
-    def __init__(self, name: str, annotator_logic: AnnotatorLogic, uuid: Optional[str] = None):
-        super().__init__(name, uuid=uuid, node_type='annotation_node')
-        self.tool = annotator_logic
-        self.histories: Dict = {}
-        annotator_logic.init(self)
-
-    def register_sio_events(self, sio_client: AsyncClient):
-
-        @sio_client.event
-        async def handle_user_input(user_input_dict):
-            return await self._handle_user_input(user_input_dict)
-
-        @sio_client.event
-        async def user_logout(sid):
-            self.reset_history(sid)
-            return self.tool.logout_user(sid)
-
-    async def _handle_user_input(self, user_input_dict: Dict) -> str:
-        if not self.sio_client or not self.sio_client.connected:
-            raise ConnectionError('SocketIO client is not connected')
-
-        user_input = from_dict(data_class=UserInput, data=user_input_dict)
-
-        if user_input.data.key_up == 'Escape':
-            self.reset_history(user_input.frontend_id)
-            return ''
-
-        await self.download_image(user_input.data.context, user_input.data.image_uuid)
-
-        try:
-            tool_result = await self.tool.handle_user_input(user_input, self.get_history(user_input.frontend_id))
-        except Exception:
-            self.reset_history(user_input.frontend_id)
-            raise
-
-        if tool_result.annotation:
-            await self.sio_client.call('update_segmentation_annotation', (user_input.data.context.organization,
-                                                                          user_input.data.context.project,
-                                                                          jsonable_encoder(asdict(tool_result.annotation))), timeout=30)
-        return tool_result.svg
-
-    def reset_history(self, frontend_id: str) -> None:
-        """Reset the history for a given frontend_id."""
-        if frontend_id in self.histories:
-            del self.histories[frontend_id]
-
-    def get_history(self, frontend_id: str) -> Dict:
-        """Get the history for a given frontend_id. If no history exists, create a new one."""
-        return self.histories.setdefault(frontend_id, self.tool.create_empty_history())
-
-    async def send_status(self):
-
-        if not self.sio_client or not self.sio_client.connected:
-            raise ConnectionError('SocketIO client is not connected')
-
-        status = AnnotationNodeStatus(
-            id=self.uuid,
-            name=self.name,
-            state=NodeState.Online,
-            capabilities=['segmentation']
-        )
-
-        self.log_status_on_change(status.state.value if status.state else 'None', status)
-
-        try:
-            result = await self.sio_client.call('update_annotation_node', jsonable_encoder(asdict(status)), timeout=10)
-        except Exception:
-            self.socket_connection_broken = True
-            self.log.exception('Error for updating:')
-            return
-
-        if not isinstance(result, Dict):
-            self.socket_connection_broken = True
-            self.log.error('Expected Dict, got %s', type(result))
-            return
-
-        response = from_dict(data_class=SocketResponse, data=result)
-
-        if not response.success:
-            self.socket_connection_broken = True
-            self.log.error('Response from loop was: %s', asdict(response))
-
-    async def download_image(self, context: Context, uuid: str):
-        project_folder = create_project_folder(context)
-        images_folder = create_image_folder(project_folder)
-
-        downloader = DataExchanger(context=context, loop_communicator=self.loop_communicator)
-        await downloader.download_images([uuid], images_folder)
-
-    async def on_startup(self):
-        pass
-
-    async def on_shutdown(self):
-        pass
-
-    async def on_repeat(self):
-        await self.send_status()

learning_loop_node/data_classes/__init__.py

@@ -1,50 +0,0 @@
-from .annotation_data import (
-    AnnotationData,
-    SegmentationAnnotation,
-    ToolOutput,
-    UserInput,
-)
-from .detections import (
-    BoxDetection,
-    ClassificationDetection,
-    Detections,
-    Observation,
-    Point,
-    PointDetection,
-    SegmentationDetection,
-    Shape,
-)
-from .general import (
-    AboutResponse,
-    AnnotationNodeStatus,
-    Category,
-    Context,
-    DetectorStatus,
-    ErrorConfiguration,
-    ModelInformation,
-    ModelVersionResponse,
-    NodeState,
-    NodeStatus,
-)
-from .image_metadata import ImageMetadata, ImagesMetadata
-from .socket_response import SocketResponse
-from .training import (
-    Errors,
-    PretrainedModel,
-    Training,
-    TrainingError,
-    TrainingOut,
-    TrainingStateData,
-    TrainingStatus,
-)
-
-__all__ = [
-    'AboutResponse', 'AnnotationData', 'SegmentationAnnotation', 'ToolOutput', 'UserInput',
-    'BoxDetection', 'ClassificationDetection', 'ImageMetadata', 'Observation', 'Point', 'PointDetection',
-    'SegmentationDetection', 'Shape', 'Detections',
-    'AnnotationNodeStatus', 'Category', 'Context', 'DetectorStatus', 'ErrorConfiguration',
-    'ModelInformation', 'NodeState', 'NodeStatus', 'ModelVersionResponse', 'ImagesMetadata',
-    'SocketResponse',
-    'Errors', 'PretrainedModel', 'Training',
-    'TrainingError', 'TrainingOut', 'TrainingStateData', 'TrainingStatus',
-]

learning_loop_node/data_classes/annotation_data.py

@@ -1,43 +0,0 @@
-import sys
-from dataclasses import dataclass
-from typing import Optional, Union
-
-from ..enums import AnnotationEventType
-from .detections import Point, Shape
-from .general import Category, Context
-
-KWONLY_SLOTS = {'kw_only': True, 'slots': True} if sys.version_info >= (3, 10) else {}
-
-
-@dataclass(**KWONLY_SLOTS)
-class AnnotationData():
-    coordinate: Point
-    event_type: Union[AnnotationEventType, str]
-    context: Context
-    image_uuid: str
-    category: Category
-
-    key_up: Optional[str] = None
-    key_down: Optional[str] = None
-    epsilon: Optional[float] = None
-    is_shift_key_pressed: Optional[bool] = None
-
-
-@dataclass(**KWONLY_SLOTS)
-class SegmentationAnnotation():
-    id: str
-    shape: Shape
-    image_id: str
-    category_id: str
-
-
-@dataclass(**KWONLY_SLOTS)
-class UserInput():
-    frontend_id: str
-    data: AnnotationData
-
-
-@dataclass(**KWONLY_SLOTS)
-class ToolOutput():
-    svg: str
-    annotation: Optional[SegmentationAnnotation] = None

learning_loop_node/data_classes/annotations.py

@@ -1,44 +0,0 @@
-
-import sys
-from dataclasses import dataclass, field
-from typing import Optional
-
-KWONLY_SLOTS = {'kw_only': True, 'slots': True} if sys.version_info >= (3, 10) else {}
-
-
-@dataclass(**KWONLY_SLOTS)
-class BoxAnnotation():
-    """Coordinates according to COCO format. x,y is the top left corner of the box.
-    x increases to the right, y increases downwards.
-    """
-    category_name: str = field(metadata={'description': 'Category name'})
-    x: int = field(metadata={'description': 'X coordinate (left to right)'})
-    y: int = field(metadata={'description': 'Y coordinate (top to bottom)'})
-    width: int = field(metadata={'description': 'Width'})
-    height: int = field(metadata={'description': 'Height'})
-    category_id: Optional[str] = field(default=None, metadata={'description': 'Category UUID'})
-
-    def __str__(self):
-        return f'x:{int(self.x)} y: {int(self.y)}, w: {int(self.width)} h: {int(self.height)} -> {self.category_name}'
-
-
-@dataclass(**KWONLY_SLOTS)
-class PointAnnotation():
-    """Coordinates according to COCO format. x,y is the center of the point.
-    x increases to the right, y increases downwards."""
-    category_name: str = field(metadata={'description': 'Category name'})
-    x: float = field(metadata={'description': 'X coordinate (right)'})
-    y: float = field(metadata={'description': 'Y coordinate (down)'})
-    category_id: Optional[str] = field(default=None, metadata={'description': 'Category UUID'})
-
-    def __str__(self):
-        return f'x:{int(self.x)} y: {int(self.y)}, -> {self.category_name}'
-
-
-@dataclass(**KWONLY_SLOTS)
-class ClassificationAnnotation():
-    category_name: str = field(metadata={'description': 'Category name'})
-    category_id: Optional[str] = field(default=None, metadata={'description': 'Category UUID'})
-
-    def __str__(self):
-        return f'-> {self.category_name}'

learning_loop_node/data_classes/detections.py

@@ -1,136 +0,0 @@
-
-import sys
-from dataclasses import dataclass, field
-from datetime import datetime, timedelta
-from typing import List, Optional, Union
-
-import numpy as np
-
-KWONLY_SLOTS = {'kw_only': True, 'slots': True} if sys.version_info >= (3, 10) else {}
-
-
-@dataclass(**KWONLY_SLOTS)
-class BoxDetection():
-    """Coordinates according to COCO format. x,y is the top left corner of the box.
-    x increases to the right, y increases downwards.
-    """
-    category_name: str = field(metadata={'description': 'Category name'})
-    x: int = field(metadata={'description': 'X coordinate (left to right)'})
-    y: int = field(metadata={'description': 'Y coordinate (top to bottom)'})
-    width: int = field(metadata={'description': 'Width'})
-    height: int = field(metadata={'description': 'Height'})
-    model_name: str = field(metadata={'description': 'Model name'})
-    confidence: float = field(metadata={'description': 'Confidence'})
-    category_id: Optional[str] = field(default=None, metadata={'description': 'Category UUID'})
-
-    def intersection_over_union(self, other_detection: 'BoxDetection') -> float:
-        # https://www.pyimagesearch.com/2016/11/07/intersection-over-union-iou-for-object-detection/
-        xA = max(self.x, other_detection.x)
-        yA = max(self.y, other_detection.y)
-        xB = min(self.x + self.width, other_detection.x + other_detection.width)
-        yB = min(self.y + self.height, other_detection.y +
-                 other_detection.height)
-
-        interArea = max(xB - xA, 0) * max(yB - yA, 0)
-        union = float(self._get_area() + other_detection._get_area() - interArea)  # pylint: disable=protected-access
-        if union == 0:
-            print("WARNING: something went wrong while calculating iou")
-            return 0
-
-        return interArea / union
-
-    def _get_area(self) -> int:
-        return self.width * self.height
-
-    def __str__(self):
-        return f'x:{int(self.x)} y: {int(self.y)}, w: {int(self.width)} h: {int(self.height)} c: {self.confidence:.2f} -> {self.category_name}'
-
-
-@dataclass(**KWONLY_SLOTS)
-class PointDetection():
-    """Coordinates according to COCO format. x,y is the center of the point.
-    x increases to the right, y increases downwards."""
-    category_name: str = field(metadata={'description': 'Category name'})
-    x: float = field(metadata={'description': 'X coordinate (right)'})
-    y: float = field(metadata={'description': 'Y coordinate (down)'})
-    model_name: str = field(metadata={'description': 'Model name'})
-    confidence: float = field(metadata={'description': 'Confidence'})
-    category_id: Optional[str] = field(default=None, metadata={'description': 'Category UUID'})
-
-    def distance(self, other: 'PointDetection') -> float:
-        return np.sqrt((other.x - self.x)**2 + (other.y - self.y)**2)
-
-    def __str__(self):
-        return f'x:{int(self.x)} y: {int(self.y)}, c: {self.confidence:.2f} -> {self.category_name}'
-
-
-@dataclass(**KWONLY_SLOTS)
-class ClassificationDetection():
-    category_name: str = field(metadata={'description': 'Category name'})
-    model_name: str = field(metadata={'description': 'Model name'})
-    confidence: float = field(metadata={'description': 'Confidence'})
-    category_id: Optional[str] = field(default=None, metadata={'description': 'Category UUID'})
-
-    def __str__(self):
-        return f'c: {self.confidence:.2f} -> {self.category_name}'
-
-
-@dataclass(**KWONLY_SLOTS)
-class Point():
-    x: int
-    y: int
-
-    def __str__(self):
-        return f'x:{self.x} y: {self.y}'
-
-
-@dataclass(**KWONLY_SLOTS)
-class Shape():
-    points: List[Point]
-
-    def __str__(self):
-        return ', '. join([str(s) for s in self.points])
-
-
-@dataclass(**KWONLY_SLOTS)
-class SegmentationDetection():
-    category_name: str
-    shape: Union[Shape, str]
-    model_name: str
-    confidence: float
-    category_id: Optional[str] = None
-
-    def __str__(self):
-        return f'shape:{str(self.shape)}, c: {self.confidence:.2f} -> {self.category_name}'
-
-
-@dataclass(**KWONLY_SLOTS)
-class Detections():
-    box_detections: List[BoxDetection] = field(default_factory=list, metadata={
-        'description': 'List of box detections'})
-    point_detections: List[PointDetection] = field(default_factory=list, metadata={
-        'description': 'List of point detections'})
-    segmentation_detections: List[SegmentationDetection] = field(default_factory=list, metadata={
-        'description': 'List of segmentation detections'})
-    classification_detections: List[ClassificationDetection] = field(default_factory=list, metadata={
-        'description': 'List of classification detections'})
-
-    image_id: Optional[str] = field(default=None, metadata={
-        'description': 'Image uuid'})
-
-    def __len__(self):
-        return len(self.box_detections) + len(self.point_detections) + len(self.segmentation_detections) + len(self.classification_detections)
-
-
-# TODO make dataclass
-class Observation():
-
-    def __init__(self, detection: Union[BoxDetection, PointDetection, SegmentationDetection, ClassificationDetection]):
-        self.detection = detection
-        self.last_seen = datetime.now()
-
-    def update_last_seen(self):
-        self.last_seen = datetime.now()
-
-    def is_older_than(self, forget_time_in_seconds):
-        return self.last_seen < datetime.now() - timedelta(seconds=forget_time_in_seconds)