boneIO 1.3.1__tar.gz → 1.3.1.dev2__tar.gz

{boneio-1.3.1/boneio.egg-info → boneio-1.3.1.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.3.1
+Version: 1.3.1.dev2
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0

{boneio-1.3.1 → boneio-1.3.1.dev2}/boneio/components/cover/cover.py

@@ -21,7 +21,7 @@ from boneio.const import (
 from boneio.core.events import EventBus
 from boneio.core.messaging import BasicMqtt
 from boneio.core.utils import TimePeriod
-from boneio.models import CoverState, PositionDict, SavedPositionDict
+from boneio.models import CoverState, PositionDict
 from boneio.models.events import CoverEvent
 
 _LOGGER = logging.getLogger(__name__)
@@ -40,7 +40,7 @@ class BaseCoverABC(ABC):
         open_time: TimePeriod,
         close_time: TimePeriod,
         event_bus: EventBus,
-        position: float = 100.0,
+        position: int = 100,
         **kwargs,
     ) -> None:
         pass
@@ -106,12 +106,14 @@ class BaseCoverABC(ABC):
         pass
 
     @abstractmethod
-    async def run_cover(self, current_operation: str, target_position: int | None = None, **kwargs) -> None:
+    async def run_cover(
+        self, current_operation: str, target_position: float | None = None, target_tilt: float | None = None
+    ) -> None:
         """This function is called to run cover after calling open, close, toggle, toggle_open, toggle_close, set_cover_position"""
         pass
 
     @abstractmethod
-    def send_state(self, state: str, json_position: PositionDict) -> None:
+    async def send_state(self, state: str, position: float) -> None:
         pass
 
 
@@ -157,7 +159,7 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         open_time: TimePeriod,
         close_time: TimePeriod,
         event_bus: EventBus,
-        position: float = 100.0,
+        position: int = 100,
         name: str | None = None,
         **kwargs,
     ) -> None:
@@ -173,7 +175,7 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         self._open_time = open_time.total_milliseconds
         self._close_time = close_time.total_milliseconds
         self._position = position
-        self._initial_position: float = position
+        self._initial_position = None
         self._current_operation = IDLE
         self._last_operation = CLOSING
         _LOGGER.debug(
@@ -186,7 +188,7 @@ class BaseCover(BaseCoverABC, BasicMqtt):
 
         self._last_timestamp = time.time()
 
-        self._last_update_time = 0.0
+        self._last_update_time = 0
         self._closed = position <= 0
 
         self._movement_thread = None
@@ -354,8 +356,7 @@ class BaseCover(BaseCoverABC, BasicMqtt):
 
     @property
     def position(self) -> int:
-        """Return current cover position as integer (0-100)."""
-        return round(self._position)
+        return round(self._position, 0)
 
     @property
     def json_position(self) -> PositionDict:
@@ -383,12 +384,6 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=state)
         self._message_bus.send_message(topic=f"{self._send_topic}/pos", payload=json.dumps(json_position))
 
-    @property
-    def saved_position(self) -> SavedPositionDict:
-        """Raw float position for disk persistence."""
-        return {"position": self._position}
-
     def send_state_and_save(self, json_position: PositionDict):
-        """Send state to MQTT/WebSocket and save raw float position to disk."""
         self.send_state(self.state, json_position)
-        self._state_save(self.saved_position)
+        self._state_save(json_position)

{boneio-1.3.1 → boneio-1.3.1.dev2}/boneio/components/cover/time_based.py

@@ -31,7 +31,7 @@ class TimeBasedCover(BaseCover):
         restored_state: dict = DEFAULT_RESTORED_STATE,
         **kwargs,
     ) -> None:
-        position = float(restored_state.get("position", DEFAULT_RESTORED_STATE["position"]))
+        position = int(restored_state.get("position", DEFAULT_RESTORED_STATE["position"]))
         super().__init__(
             open_relay=open_relay,
             close_relay=close_relay,
@@ -113,7 +113,7 @@ class TimeBasedCover(BaseCover):
             self._loop.call_soon_threadsafe(lambda: self.send_state_and_save(self.json_position))
         self._last_update_time = time.monotonic()  # Upewnij się, że aktualizacja jest wysłana na końcu ruchu
 
-    async def run_cover(self, current_operation: str, target_position: int | None = None, **kwargs) -> None:
+    async def run_cover(self, current_operation: str, target_position: int | None = None) -> None:
         if self._movement_thread and self._movement_thread.is_alive():
             _LOGGER.warning("Cover movement already in progress. Stopping first.")
             await self.stop()

{boneio-1.3.1 → boneio-1.3.1.dev2}/boneio/components/cover/venetian.py

@@ -8,7 +8,7 @@ import time
 from boneio.components.cover.cover import BaseCover, BaseVenetianCoverABC
 from boneio.const import CLOSE, CLOSING, IDLE, OPEN, OPENING, STOP
 from boneio.core.utils import TimePeriod
-from boneio.models import PositionDict, SavedPositionDict
+from boneio.models import PositionDict
 
 _LOGGER = logging.getLogger(__name__)
 COVER_MOVE_UPDATE_INTERVAL = 50  # ms
@@ -27,12 +27,20 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         restored_state: dict = DEFAULT_RESTORED_STATE,
         **kwargs,
     ) -> None:
-        self._tilt_duration = tilt_duration.total_milliseconds  # Czas trwania ruchu lameli
-        self._initial_tilt_position = float(restored_state.get("tilt", DEFAULT_RESTORED_STATE["tilt"]))
+        self._tilt_duration = (
+            tilt_duration.total_milliseconds
+        )  # Czas trwania ruchu lameli
+        self._initial_tilt_position = int(
+            restored_state.get("tilt", DEFAULT_RESTORED_STATE["tilt"])
+        )
 
-        position = float(restored_state.get("position", DEFAULT_RESTORED_STATE["position"]))
+        position = int(
+            restored_state.get("position", DEFAULT_RESTORED_STATE["position"])
+        )
         # --- TILT ---
-        self._tilt_position = float(restored_state.get("tilt", DEFAULT_RESTORED_STATE["tilt"]))
+        self._tilt_position = int(
+            restored_state.get("tilt", DEFAULT_RESTORED_STATE["tilt"])
+        )
 
         # self._actuator_activation_duration = (
         #     actuator_activation_duration.total_milliseconds
@@ -45,12 +53,7 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         )
         _LOGGER.debug(
             "VenetianCover %s initialized: open_time=%dms, close_time=%dms, tilt_duration=%dms, position=%d%%, tilt=%d%%",
-            self._id,
-            self._open_time,
-            self._close_time,
-            self._tilt_duration,
-            position,
-            self._tilt_position,
+            self._id, self._open_time, self._close_time, self._tilt_duration, position, self._tilt_position
         )
 
     def _move_cover(
@@ -66,12 +69,20 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         if direction == OPEN:
             relay = self._open_relay
             total_steps = 100 - self._position
-            total_tilt_step = tilt_delta if target_tilt_position is not None else 100 - self._initial_tilt_position
+            total_tilt_step = (
+                tilt_delta
+                if target_tilt_position is not None
+                else 100 - self._initial_tilt_position
+            )
 
         elif direction == CLOSE:
             relay = self._close_relay
             total_steps = self._position
-            total_tilt_step = tilt_delta if target_tilt_position is not None else self._initial_tilt_position
+            total_tilt_step = (
+                tilt_delta
+                if target_tilt_position is not None
+                else self._initial_tilt_position
+            )
         else:
             return
         if target_tilt_position is not None:
@@ -82,7 +93,9 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
 
         if total_steps == 0 or duration == 0:
             self._current_operation = IDLE
-            self._loop.call_soon_threadsafe(self.send_state, self.state, self.json_position)
+            self._loop.call_soon_threadsafe(
+                self.send_state, self.state, self.json_position
+            )
             return
 
         # Calculate actual duration based on remaining distance
@@ -98,11 +111,17 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         needed_tilt_duration = tilt_duration * (total_tilt_step / 100)
         if target_tilt_position is None:
             tilt_delta = 1.0
+            
 
         while not self._stop_event.is_set():
-            current_time = time.monotonic()  # Pobierz aktualny czas tylko raz na iterację
-            elapsed_time = (current_time - start_time) * 1000  # Konwersja na milisekundy
-
+            current_time = (
+                time.monotonic()
+            )  # Pobierz aktualny czas tylko raz na iterację
+            elapsed_time = (
+                current_time - start_time
+            ) * 1000  # Konwersja na milisekundy
+
+           
             if elapsed_time < needed_tilt_duration:
                 tilt_progress = elapsed_time / needed_tilt_duration if needed_tilt_duration > 0 else 1.0
                 progress = 0.0
@@ -116,10 +135,8 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
 
                 # Obliczanie _tilt_position dla kierunku OPEN
                 if target_tilt_position is not None:
-                    self._tilt_position = min(
-                        target_tilt_position, self._initial_tilt_position + tilt_progress * tilt_delta
-                    )
-                else:  # Fallback jeśli nie ma target_tilt_position
+                    self._tilt_position = min(target_tilt_position, self._initial_tilt_position + tilt_progress * tilt_delta)
+                else: # Fallback jeśli nie ma target_tilt_position
                     self._tilt_position = min(
                         100.0, self._initial_tilt_position + tilt_progress * (100 - self._initial_tilt_position)
                     )
@@ -129,23 +146,24 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
 
                 # Obliczanie _tilt_position dla kierunku CLOSE
                 if target_tilt_position is not None:
-                    self._tilt_position = max(
-                        target_tilt_position, self._initial_tilt_position - tilt_progress * tilt_delta
-                    )
-                else:  # Fallback jeśli nie ma target_tilt_position
+                    self._tilt_position = max(target_tilt_position, self._initial_tilt_position - tilt_progress * tilt_delta)
+                else: # Fallback jeśli nie ma target_tilt_position
                     self._tilt_position = max(
                         0.0, self._initial_tilt_position - tilt_progress * self._initial_tilt_position
                     )
 
             self._last_timestamp = time.time()  # Wall clock for display
             if current_time - self._last_update_time >= 1:
-                self._loop.call_soon_threadsafe(self.send_state, self.state, self.json_position)
+                self._loop.call_soon_threadsafe(
+                    self.send_state, self.state, self.json_position
+                )
                 self._last_update_time = current_time
 
-            if target_tilt_position is not None and (
-                (direction == OPEN and self._tilt_position >= target_tilt_position)
-                or (direction == CLOSE and self._tilt_position <= target_tilt_position)
-            ):
+            if target_tilt_position is not None and ((
+                direction == OPEN and self._tilt_position >= target_tilt_position
+            ) or (
+                direction == CLOSE and self._tilt_position <= target_tilt_position
+            )):
                 break
 
             if target_position is not None and (
@@ -165,8 +183,12 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         # Send relay state to WebSocket (not MQTT - that's handled by output_type check)
         self._loop.call_soon_threadsafe(lambda r=relay: asyncio.ensure_future(r.async_send_state()))
         self._current_operation = IDLE
-        self._loop.call_soon_threadsafe(self.send_state_and_save, self.json_position)
-        self._last_update_time = time.monotonic()  # Upewnij się, że aktualizacja jest wysłana na końcu ruchu
+        self._loop.call_soon_threadsafe(
+            self.send_state_and_save, self.json_position
+        )
+        self._last_update_time = (
+            time.monotonic()
+        )  # Upewnij się, że aktualizacja jest wysłana na końcu ruchu
 
     async def set_tilt(self, tilt_position: int) -> None:
         """Setting tilt position."""
@@ -178,36 +200,31 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
 
         tilt_diff = abs(self._tilt_position - tilt_position)
         estimated_time_s = tilt_diff / 100 * self._tilt_duration / 1000
-
+        
         if tilt_position > self._tilt_position:
             _LOGGER.info(
                 "Setting tilt %s from %d%% to %d%% (OPENING). Estimated time: %.2fs (tilt_duration=%dms)",
-                self._id,
-                self._tilt_position,
-                tilt_position,
-                estimated_time_s,
-                self._tilt_duration,
+                self._id, self._tilt_position, tilt_position, estimated_time_s, self._tilt_duration
+            )
+            await self.run_cover(
+                current_operation=OPENING, target_tilt_position=tilt_position
             )
-            await self.run_cover(current_operation=OPENING, target_tilt_position=tilt_position)
         elif tilt_position < self._tilt_position:
             _LOGGER.info(
                 "Setting tilt %s from %d%% to %d%% (CLOSING). Estimated time: %.2fs (tilt_duration=%dms)",
-                self._id,
-                self._tilt_position,
-                tilt_position,
-                estimated_time_s,
-                self._tilt_duration,
+                self._id, self._tilt_position, tilt_position, estimated_time_s, self._tilt_duration
+            )
+            await self.run_cover(
+                current_operation=CLOSING, target_tilt_position=tilt_position
             )
-            await self.run_cover(current_operation=CLOSING, target_tilt_position=tilt_position)
 
     @property
     def json_position(self) -> PositionDict:
-        """Return position dict with int values for API/MQTT/WebUI."""
-        return {"position": self.position, "tilt": self.tilt}
+        return {"position": round(self.position, 0), "tilt": self.tilt}
 
     @property
     def tilt(self) -> int:
-        return round(self._tilt_position)
+        return int(round(self._tilt_position, 0))
 
     @property
     def tilt_position(self) -> int:
@@ -228,11 +245,6 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
     def kind(self) -> str:
         return "venetian"
 
-    @property
-    def saved_position(self) -> SavedPositionDict:
-        """Raw float position for disk persistence (includes tilt)."""
-        return {"position": self._position, "tilt": self._tilt_position}
-
     async def set_cover_tilt_position(self, position: int) -> None:
         """Set cover tilt position (required by BaseVenetianCoverABC)."""
         await self.set_tilt(position)
@@ -242,10 +254,7 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         estimated_time_s = (100 - self._tilt_position) / 100 * self._tilt_duration / 1000
         _LOGGER.info(
             "Opening tilt cover %s from %d%%. Estimated time: %.2fs (tilt_duration=%dms)",
-            self._id,
-            self._tilt_position,
-            estimated_time_s,
-            self._tilt_duration,
+            self._id, self._tilt_position, estimated_time_s, self._tilt_duration
         )
         await self.set_tilt(tilt_position=100)
 
@@ -254,16 +263,13 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         estimated_time_s = self._tilt_position / 100 * self._tilt_duration / 1000
         _LOGGER.info(
             "Closing tilt cover %s from %d%%. Estimated time: %.2fs (tilt_duration=%dms)",
-            self._id,
-            self._tilt_position,
-            estimated_time_s,
-            self._tilt_duration,
+            self._id, self._tilt_position, estimated_time_s, self._tilt_duration
         )
         await self.set_tilt(tilt_position=0)
 
     def update_config_times(self, config: dict) -> None:
         """Update cover timing configuration.
-
+        
         Args:
             config: Dictionary with timing values as TimePeriod objects.
                    Keys: open_time, close_time, tilt_duration
@@ -280,12 +286,11 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         current_operation: str,
         target_position: int | None = None,
         target_tilt_position: int | None = None,
-        **kwargs,
     ) -> None:
         if self._movement_thread and self._movement_thread.is_alive():
             _LOGGER.warning("Cover movement is already in progress. Stopping first.")
             await self.stop()
-
+        
         # If STOP was requested, don't start new movement
         if current_operation == STOP:
             await self.stop()
@@ -295,7 +300,9 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         self._initial_position = self._position
         self._initial_tilt_position = self._tilt_position
         self._stop_event.clear()
-        self._last_update_time = time.monotonic()  # Inicjalizacja czasu ostatniej aktualizacji
+        self._last_update_time = (
+            time.monotonic()
+        )  # Inicjalizacja czasu ostatniej aktualizacji
 
         if current_operation == OPENING:
             self._movement_thread = threading.Thread(

{boneio-1.3.1 → boneio-1.3.1.dev2}/boneio/core/manager/covers.py

@@ -230,7 +230,7 @@ class CoverManager:
 
         platform = config.get("platform", "time_based")
 
-        def state_save(value: dict[str, float]):
+        def state_save(value: dict[str, int]):
             if config[RESTORE_STATE]:
                 self._manager._state_manager.save_attribute(
                     attr_type=COVER,

{boneio-1.3.1 → boneio-1.3.1.dev2}/boneio/hardware/display/early_oled.py

@@ -28,7 +28,7 @@ _taken_over: bool = False  # Set True when DisplayManager takes control
 
 def _get_fonts() -> dict[str, Any] | None:
     """Lazily load fonts for OLED display.
-
+    
     Returns:
         Dictionary with font objects keyed by size name, or None if
         no font libraries are available (PIL/Pillow not installed).
@@ -39,7 +39,6 @@ def _get_fonts() -> dict[str, Any] | None:
 
     try:
         from boneio.core.utils.font_util import make_font
-
         _fonts = {
             "big": make_font("DejaVuSans.ttf", 12),
             "small": make_font("DejaVuSans.ttf", 9),
@@ -49,7 +48,6 @@ def _get_fonts() -> dict[str, Any] | None:
     except (OSError, ImportError):
         try:
             from PIL import ImageFont
-
             _LOGGER.debug("TTF fonts not found, using default PIL fonts")
             _fonts = {
                 "big": ImageFont.load_default(),
@@ -65,13 +63,13 @@ def _get_fonts() -> dict[str, Any] | None:
 
 def init_early_oled() -> Any | None:
     """Initialize bare OLED device for startup status messages.
-
+    
     Creates the I2C connection and SH1106 device early, before the Manager
     or even config validation. This allows displaying boot progress,
     config errors, and crash info on the OLED screen.
-
+    
     Call this once at the very start of the application.
-
+    
     Returns:
         sh1106 device instance or None if OLED hardware is not available.
     """
@@ -82,7 +80,6 @@ def init_early_oled() -> Any | None:
     try:
         from luma.core.interface.serial import i2c
         from luma.oled.device import sh1106
-
         serial = i2c(port=2, address=0x3C)
         _early_device = sh1106(serial)
         _LOGGER.debug("Early OLED device initialized for startup messages")
@@ -94,7 +91,7 @@ def init_early_oled() -> Any | None:
 
 def get_early_device() -> Any | None:
     """Get the early-initialized OLED device singleton.
-
+    
     Returns:
         sh1106 device instance or None if not initialized.
     """
@@ -103,7 +100,7 @@ def get_early_device() -> Any | None:
 
 def handoff() -> None:
     """Signal that DisplayManager has taken over the OLED.
-
+    
     After this call, draw_status/draw_error/draw_config_error become no-ops.
     Only draw_crash still works (safety — must always show fatal errors).
     """
@@ -119,9 +116,9 @@ def is_taken_over() -> bool:
 
 def draw_status(message: str, device: Any | None = None) -> None:
     """Draw a startup/status message on the OLED display.
-
+    
     Shows the boneIO logo at the top and a status line below.
-
+    
     Args:
         message: Status message to display (max ~20 chars for good readability).
         device: Optional device override; uses singleton if not provided.
@@ -131,7 +128,6 @@ def draw_status(message: str, device: Any | None = None) -> None:
         return
     try:
         from luma.core.render import canvas
-
         fonts = _get_fonts()
         if fonts is None:
             return
@@ -145,10 +141,10 @@ def draw_status(message: str, device: Any | None = None) -> None:
 
 def draw_error(title: str, detail: str, device: Any | None = None) -> None:
     """Draw an error message on the OLED display.
-
+    
     Shows a warning icon, error title, and up to 4 lines of wrapped detail.
     The screen stays visible until manually cleared or the app restarts.
-
+    
     Args:
         title: Short error title (e.g., "Config Error", "Runtime Error").
         detail: Detailed error description (will be word-wrapped).
@@ -159,7 +155,6 @@ def draw_error(title: str, detail: str, device: Any | None = None) -> None:
         return
     try:
         from luma.core.render import canvas
-
         fonts = _get_fonts()
         if fonts is None:
             return
@@ -187,26 +182,26 @@ def draw_error(title: str, detail: str, device: Any | None = None) -> None:
 
 def draw_config_error(error_message: str, device: Any | None = None) -> None:
     """Draw a configuration error on the OLED display.
-
+    
     Specialized version of draw_error for config validation failures.
-
+    
     Args:
         error_message: The configuration error description.
         device: Optional device override; uses singleton if not provided.
     """
     draw_error(
         title="Config Error",
-        detail=error_message,
+        detail=str(error_message),
         device=device,
     )
 
 
 def draw_crash(exception: BaseException, device: Any | None = None) -> None:
     """Draw a crash/runtime error on the OLED display.
-
+    
     This function ALWAYS works, even after handoff() — crashes must be
     visible to the user regardless of which component owns the screen.
-
+    
     Args:
         exception: The exception that caused the crash.
         device: Optional device override; uses singleton if not provided.
@@ -228,7 +223,7 @@ def draw_crash(exception: BaseException, device: Any | None = None) -> None:
 
 def clear_display(device: Any | None = None) -> None:
     """Clear the OLED display (turn all pixels off).
-
+    
     Args:
         device: Optional device override; uses singleton if not provided.
     """
@@ -237,7 +232,6 @@ def clear_display(device: Any | None = None) -> None:
         return
     try:
         from luma.core.render import canvas
-
         with canvas(dev) as draw:
             draw.rectangle([0, 0, 127, 63], outline=0, fill=0)
     except Exception as err:

{boneio-1.3.1 → boneio-1.3.1.dev2}/boneio/hardware/gpio/input/base.py

@@ -277,15 +277,13 @@ class GpioBaseClass:
         """
         return self._sequence_mode
 
-    def should_publish_sequence_to_mqtt(self, sequence_type: ClickTypes | None) -> bool:
+    def should_publish_sequence_to_mqtt(self, sequence_type: str) -> bool:
         """Check if a sequence type should be published to MQTT.
 
         Args:
-            sequence_type: Type of sequence (e.g., 'double_then_long'), or None
+            sequence_type: Type of sequence (e.g., 'double_then_long')
 
         Returns:
             True if the sequence should be published to MQTT
         """
-        if sequence_type is None:
-            return False
         return self._mqtt_sequences.get(sequence_type, False)

{boneio-1.3.1 → boneio-1.3.1.dev2}/boneio/models/__init__.py

@@ -25,7 +25,6 @@ from boneio.models.state import (
     OutputsResponse,
     OutputState,
     PositionDict,
-    SavedPositionDict,
     SensorState,
 )
 
@@ -53,5 +52,4 @@ __all__ = [
     "StateUpdate",
     # Utility
     "PositionDict",
-    "SavedPositionDict",
 ]

{boneio-1.3.1 → boneio-1.3.1.dev2}/boneio/models/state.py

@@ -116,17 +116,11 @@ class CoverResponse(BaseModel):
 
 # Utility types
 class PositionDict(TypedDict, total=False):
-    """Position dictionary for covers — used for API/MQTT/WebUI (rounded int values)."""
+    """Position dictionary for covers."""
     position: int
     tilt: int
 
 
-class SavedPositionDict(TypedDict, total=False):
-    """Position dictionary for covers — used for disk persistence (full float precision)."""
-    position: float
-    tilt: float
-
-
 __all__ = [
     # State models
     "InputState",
@@ -141,7 +135,6 @@ __all__ = [
     "CoverResponse",
     # Utility
     "PositionDict",
-    "SavedPositionDict",
     "ModbusDeviceState",
 ]
 

boneio-1.3.1.dev2/boneio/version.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+__version__ = "1.3.1dev2"