move around code, fix some circular imports, change some base agents to extend off of AgentBase instead of Agent and some other small fixes

Author: Ademfcan

Alt-Cameras/src/Alt/Cameras/Agents/CameraUsingAgentBase.py

@@ -3,9 +3,9 @@
 import cv2
 import numpy as np
 
-from Alt.Core.Agents import Agent, BindableAgent
+from Alt.Core.Agents import AgentBase, BindableAgent
 from Alt.Core.Constants.AgentConstants import ProxyType
-from Alt.Core.Operators.StreamOperator import StreamProxy
+from Alt.Core.Operators.StreamProxy import StreamProxy
 
 from ..Captures.OpenCVCapture import OpenCVCapture
 from ..Captures.Capture import Capture, CaptureWIntrinsics, ConfigurableCapture
@@ -15,7 +15,7 @@
 from ..Calibration.CalibrationUtil import CalibrationUtil
 
 
-class CameraUsingAgentBase(Agent, BindableAgent):
+class CameraUsingAgentBase(AgentBase, BindableAgent):
     """
     Main superclass for any agent that needs to use a camera. It is reccomended to extend this rather than create a separate agent class.
     Adds calibration support, automatic mjpeg streaming, camera status checking, and depth camera support

Alt-Core/src/Alt/Core/Agents/Agent.py

@@ -7,15 +7,16 @@
 from JXTABLES.XTablesClient import XTablesClient
 
 from ..Utils.network import DEVICEIP
+from ..Operators.LogStreamOperator import LOGPATH
+from ..Operators.StreamProxy import StreamProxy
+
 
 if TYPE_CHECKING:
     from ..Constants.AgentConstants import Proxy, ProxyType
     from ..Constants.Teams import TEAM
     from ..Operators.ConfigOperator import ConfigOperator
-    from ..Operators.LogStreamOperator import LogStreamOperator
     from ..Operators.PropertyOperator import PropertyOperator
     from ..Operators.ShareOperator import ShareOperator
-    from ..Operators.StreamOperator import StreamProxy
     from ..Operators.TimeOperator import TimeOperator, Timer
     from ..Operators.UpdateOperator import UpdateOperator
 
@@ -173,6 +174,9 @@ def _updateNetworkProxyInfo(self):
             if isinstance(proxy, StreamProxy):
                 streamPaths.append(f"{proxyName}|{proxy.getStreamPath()}")
 
+                print(f"STREAM PROXY PATH: {proxy.getStreamPath()}")
+
+
         self.propertyOperator.createCustomReadOnlyProperty(
             "streamPaths", streamPaths, addBasePrefix=True, addOperatorPrefix=True
         )
@@ -210,12 +214,14 @@ def getTeam(self) -> Optional[TEAM]:
     def _runOwnCreate(self):
         """The agent wants to do its own stuff too... okay."""
 
-        logIp = f"http://{DEVICEIP}:5000/{self.agentName}/{LogStreamOperator.LOGPATH}"
+        logIp = f"http://{DEVICEIP}:5000/{self.agentName}/{LOGPATH}"
 
         self.propertyOperator.createCustomReadOnlyProperty(
             "logIP", logIp, addBasePrefix=True, addOperatorPrefix=True
         )
 
+        print(f"LOGIP: {logIp}")
+
         self.__ensureProxies()
         self._updateNetworkProxyInfo()
 
@@ -272,12 +278,10 @@ def onClose(self) -> None:
 
     # ----- proxy methods -----
     def __ensureProxies(self) -> None:
-        for proxyName, proxyType in self._getProxyRequests().items():
+        for proxyName, _ in self._getProxyRequests().items():
             if (
                 proxyName not in self.__proxies
-                or type(self.__proxies[proxyName]) is not proxyType
             ):
-                print(type(self.__proxies[proxyName]) is proxyType)
                 raise RuntimeError(
                     f"Agent proxies are not correcty initialized!\n{self._getProxyRequests()=}\n{self.__proxies.items()=}"
                 )

Alt-Core/src/Alt/Core/Constants/AgentConstants.py

@@ -3,9 +3,11 @@
 from abc import abstractmethod
 from enum import Enum
 from functools import partial
-from typing import Any, Dict, cast
+from typing import Any, Dict, cast, TYPE_CHECKING
 
-from Alt.Core.Agents import Agent
+
+if TYPE_CHECKING:
+    from Alt.Core.Agents import Agent
 
 
 class ProxyType(Enum):
@@ -28,6 +30,7 @@ def getProxyRequests(agentClass) -> Dict[str, "ProxyType"]:
     def __getPartialProxyRequests(
         agentClass: partial[type[Agent]],
     ) -> Dict[str, "ProxyType"]:
+        from Alt.Core.Agents import Agent
         agentClassType = cast(Agent, agentClass.func)
         agentClassType.requestProxies()
         return agentClassType._getProxyRequests()
@@ -46,3 +49,4 @@ def put(self, value: Any):
     @abstractmethod
     def get(self) -> Any:
         pass
+    

Alt-Core/src/Alt/Core/Constants/field.py

@@ -32,3 +32,28 @@ def getHeight(self, units: Types.Length = Types.Length.CM) -> float:
             self.height, fromType=self.units, toType=units
         )
         return cast(float, result)
+
+    def invertY(y: Conversions.NumericType, lengthType: Types.Length = Types.Length.CM) -> float:
+        """
+        Invert the Y coordinate relative to field height
+
+        Args:
+            yCM: Y coordinate in units specified, or by default CM
+
+        Returns:
+            Inverted Y coordinate (field height - Y)
+        """
+        return Field.getInstance().getHeight(lengthType) - y
+
+
+    def invertX(x: Conversions.NumericType, lengthType: Types.Length = Types.Length.CM) -> float:
+        """
+        Invert the X coordinate relative to field width
+
+        Args:
+            xCM: X coordinate in the units specified, or by default CM
+
+        Returns:
+            Inverted X coordinate (field width - X)
+        """
+        return Field.getInstance().getWidth(lengthType) - x

Alt-Core/src/Alt/Core/Operators/LogStreamOperator.py

@@ -18,6 +18,7 @@
 
 Sentinel = getChildLogger("Log_Stream_Operator")
 
+LOGPATH = "logs"
 
 class LogStreamOperator:
     """
@@ -31,8 +32,6 @@ class LogStreamOperator:
         running (bool): Indicates if the log stream operator is running.
     """
 
-    LOGPATH = "logs"
-
     def __init__(self, app: Flask, manager: multiprocessing.managers.SyncManager):
         """
         Initializes the LogStreamOperator.
@@ -77,7 +76,7 @@ def generate_logs(queue=log_queue):
                     continue
 
         self.app.add_url_rule(
-            f"/{name}/{self.LOGPATH}",
+            f"/{name}/{LOGPATH}",
             view_func=self._create_log_view_func(generate_logs, name),
         )
 

Alt-Core/src/Alt/Core/Operators/StreamOperator.py

@@ -12,13 +12,10 @@ class serves as a wrapper for accessing and manipulating the stream data between
 import multiprocessing
 import time
 import cv2
-import numpy as np
-from multiprocessing import managers
-from typing import Dict, Optional
+from typing import Dict
 from flask import Flask, Response, stream_with_context
-from werkzeug.serving import make_server
 from .LogOperator import getChildLogger
-from ..Constants.AgentConstants import Proxy
+from .StreamProxy import StreamProxy
 from ..Utils.network import DEVICEIP
 
 Sentinel = getChildLogger("Stream_Operator")
@@ -153,75 +150,3 @@ def close_stream(self, name: str):
             Sentinel.info(f"Closed stream: {name}")
 
 
-class StreamProxy(Proxy):
-    """Wrapper for accessing and manipulating a stream from another process.
-
-    This class extends the DictProxy used to transfer data
-    between processes, specifically for MJPEG video streaming.
-
-    Attributes:
-        __streamDict (managers.DictProxy): The underlying dictionary proxy
-        holding stream data.
-    """
-
-    def __init__(self, streamDict: managers.DictProxy, streamPath: str):
-        """Initializes a StreamProxy instance.
-
-        Args:
-            streamDict (managers.DictProxy): Proxy for accessing shared data.
-            streamPath (str): URL path of the video stream.
-        """
-        self.__streamDict = streamDict
-        self.__streamDict["stream_path"] = streamPath
-        self.__streamDict["frame_count"] = 0
-
-    def put(self, frame: np.ndarray) -> None:
-        """Stores a new video frame in the proxy.
-
-        Args:
-            frame (np.ndarray): The video frame to store.
-        """
-        self.__streamDict["frame"] = frame
-        self.__streamDict["frame_count"] = self.__streamDict.get("frame_count", 0) + 1
-
-    def get(self) -> Optional[np.ndarray]:
-        """Retrieves the current video frame from the proxy.
-
-        Returns:
-            Optional[np.ndarray]: The latest frame, or None if no frame is available.
-        """
-        return self.__streamDict.get("frame")
-
-    def getFrameCount(self) -> int:
-        """Gets the current count of frames stored in the proxy.
-
-        Returns:
-            int: The total number of frames sent.
-        """
-        return self.__streamDict["frame_count"]
-
-    def getStreamPath(self) -> str:
-        """Gets the URL path of the video stream.
-
-        Returns:
-            str: The path where the stream can be accessed.
-        """
-        return self.__streamDict["stream_path"]
-
-    def __getstate__(self):
-        """Returns the state of the StreamProxy for pickling.
-
-        This method enables the StreamProxy to be correctly serialized.
-
-        Returns:
-            managers.DictProxy: The underlying stream dictionary proxy.
-        """
-        return self.__streamDict
-
-    def __setstate__(self, state):
-        """Restores the state of the StreamProxy from a pickled state.
-
-        Args:
-            state (dict): The state to restore from.
-        """
-        self.__streamDict = state

Alt-Core/src/Alt/Core/Operators/StreamProxy.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import numpy as np
+from multiprocessing import managers
+from typing import Optional
+from .LogOperator import getChildLogger
+from ..Constants.AgentConstants import Proxy
+
+Sentinel = getChildLogger("Stream_Operator")
+
+class StreamProxy(Proxy):
+    """Wrapper for accessing and manipulating a stream from another process.
+
+    This class extends the DictProxy used to transfer data
+    between processes, specifically for MJPEG video streaming.
+
+    Attributes:
+        __streamDict (managers.DictProxy): The underlying dictionary proxy
+        holding stream data.
+    """
+
+    def __init__(self, streamDict: managers.DictProxy, streamPath: str):
+        """Initializes a StreamProxy instance.
+
+        Args:
+            streamDict (managers.DictProxy): Proxy for accessing shared data.
+            streamPath (str): URL path of the video stream.
+        """
+        self.__streamDict = streamDict
+        self.__streamDict["stream_path"] = streamPath
+        self.__streamDict["frame_count"] = 0
+
+    def put(self, frame: np.ndarray) -> None:
+        """Stores a new video frame in the proxy.
+
+        Args:
+            frame (np.ndarray): The video frame to store.
+        """
+        self.__streamDict["frame"] = frame
+        self.__streamDict["frame_count"] = self.__streamDict.get("frame_count", 0) + 1
+
+    def get(self) -> Optional[np.ndarray]:
+        """Retrieves the current video frame from the proxy.
+
+        Returns:
+            Optional[np.ndarray]: The latest frame, or None if no frame is available.
+        """
+        return self.__streamDict.get("frame")
+
+    def getFrameCount(self) -> int:
+        """Gets the current count of frames stored in the proxy.
+
+        Returns:
+            int: The total number of frames sent.
+        """
+        return self.__streamDict["frame_count"]
+
+    def getStreamPath(self) -> str:
+        """Gets the URL path of the video stream.
+
+        Returns:
+            str: The path where the stream can be accessed.
+        """
+        return self.__streamDict["stream_path"]
+
+    def __getstate__(self):
+        """Returns the state of the StreamProxy for pickling.
+
+        This method enables the StreamProxy to be correctly serialized.
+
+        Returns:
+            managers.DictProxy: The underlying stream dictionary proxy.
+        """
+        return self.__streamDict
+
+    def __setstate__(self, state):
+        """Restores the state of the StreamProxy from a pickled state.
+
+        Args:
+            state (dict): The state to restore from.
+        """
+        self.__streamDict = state

Alt-Core/src/Alt/Core/Units/Conversions.py

@@ -3,7 +3,6 @@
 from collections.abc import Iterable
 from typing import Any, Union, TypeVar, Callable, Tuple, cast
 from . import Types, Measurements
-from ..Constants import Field
 
 # Type variables for better typing
 NumericType = Union[float, int]
@@ -66,32 +65,6 @@ def toint(
     return __convert(value, int)
 
 
-def invertY(y: NumericType, lengthType: Types.Length = Types.Length.CM) -> float:
-    """
-    Invert the Y coordinate relative to field height
-
-    Args:
-        yCM: Y coordinate in units specified, or by default CM
-
-    Returns:
-        Inverted Y coordinate (field height - Y)
-    """
-    return Field.getInstance().getHeight(lengthType) - y
-
-
-def invertX(x: NumericType, lengthType: Types.Length = Types.Length.CM) -> float:
-    """
-    Invert the X coordinate relative to field width
-
-    Args:
-        xCM: X coordinate in the units specified, or by default CM
-
-    Returns:
-        Inverted X coordinate (field width - X)
-    """
-    return Field.getInstance().getWidth(lengthType) - x
-
-
 def convertLength(
     value: Union[Iterable[NumericType], NumericType],
     fromType: Types.Length,