pyobs-gemini 1.0.1__tar.gz → 2.0.0.dev1__tar.gz

pyobs_gemini-2.0.0.dev1/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: pyobs-gemini
+Version: 2.0.0.dev1
+Summary: pyobs module for Optec Gemini focusser/rotator
+Author: Tim-Oliver Husser, Frederic V. Hessman
+Author-email: Tim-Oliver Husser <thusser@uni-goettingen.de>, Frederic V. Hessman <fhessma@uni-goettingen.de>
+License-Expression: MIT
+Requires-Dist: aioserial>=1.3,<2
+Requires-Dist: astropy>=7.0.1,<8
+Requires-Dist: numpy>=2.2.5,<3
+Requires-Dist: pyobs-core>=2.0.0.dev38,<3
+Requires-Python: >=3.11, <3.14

pyobs_gemini-2.0.0.dev1/pyobs_gemini/__init__.py

@@ -0,0 +1,3 @@
+from .gemini import GeminiFocuserRotator as GeminiFocuserRotator
+
+__all__ = ["GeminiFocuserRotator"]

{pyobs_gemini-1.0.1 → pyobs_gemini-2.0.0.dev1}/pyobs_gemini/api.py

@@ -21,10 +21,11 @@ The GEMINI responses have the syntax:
    {END|SET}
 
 """
-from typing import Dict, Any, Tuple, List
+
+from typing import Any
 
 # A COMMAND CONSISTS OF name,device,command_string,input_format,output_format,end_string,help
-gemini_commands: Dict[str, Dict[str, Any]] = {
+gemini_commands: dict[str, dict[str, Any]] = {
     "CENTER": {
         "cmd": "center",
         "device": "F",
@@ -238,25 +239,25 @@ def gemini_cmd(cmd: str, *args: Any, dev: str = "", trans_id: int = 0) -> str:
     transaction ID, and whatever input args are needed.
     """
     if cmd not in gemini_commands:
-        raise ValueError("{0} is not a GEMINI command!".format(cmd))
+        raise ValueError(f"{cmd} is not a GEMINI command!")
     info = gemini_commands[cmd]
     if dev not in info["device"]:
-        raise ValueError("{0} does not match GEMINI device {1}".format(dev, info["device"]))
+        raise ValueError("{} does not match GEMINI device {}".format(dev, info["device"]))
 
-    s1 = "<{0}1{1:02d}".format(dev, trans_id)
+    s1 = f"<{dev}1{trans_id:02d}"
     s2 = cmd
     if info["format"] is None:
         s3 = ""
     else:
         try:
             s3 = info["format"].format(*args)
-        except:
-            raise ValueError("format {0} does not work for {1}".format(info["format"], cmd))
+        except Exception:
+            raise ValueError(f"format {info['format']} does not work for {cmd}")
     s4 = ">"
     return s1 + s2 + s3 + s4
 
 
-def gemini_parse_output(cmd: str, raw_response: List[bytes]) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+def gemini_parse_output(cmd: str, raw_response: list[bytes]) -> tuple[dict[str, Any], dict[str, Any]]:
     """
     Parse the raw GEMINI output, a list of bytearray's from serial.readline,
     into a dictionary.
@@ -269,13 +270,13 @@ def gemini_parse_output(cmd: str, raw_response: List[bytes]) -> Tuple[Dict[str,
     info = gemini_commands[cmd]
     if "end" not in info:
         raise IndexError("ending is not in info!")
-    results: Dict[str, Any] = {}
+    results: dict[str, Any] = {}
 
     # decode and remove newlines
     try:
         rsp = [r.decode("utf8").replace("\\n", "") for r in raw_response]
     except UnicodeDecodeError:
-        raise ValueError("{0!r} cannot be decoded".format(raw_response))
+        raise ValueError(f"{raw_response!r} cannot be decoded")
 
     # check for syntax
     if len(rsp) == 0 or not rsp[0].strip().startswith("!"):
@@ -284,7 +285,7 @@ def gemini_parse_output(cmd: str, raw_response: List[bytes]) -> Tuple[Dict[str,
     # get transaction ID
     try:
         trans_id = int(rsp[0].strip()[1:])
-    except:
+    except ValueError:
         trans_id = None
     results["trans_id"] = trans_id
     errors = {}

{pyobs_gemini-1.0.1 → pyobs_gemini-2.0.0.dev1}/pyobs_gemini/gemini.py

@@ -1,20 +1,30 @@
 import asyncio
 import logging
-from typing import Optional, List, Any, Dict, Tuple
+from typing import Any
+
+import astropy.units as u
 import numpy as np
 from astropy.coordinates import SkyCoord
-import astropy.units as u
-
-from pyobs.events import MotionStatusChangedEvent, Event
+from pyobs.events import Event, MotionStatusChangedEvent
+from pyobs.interfaces import (
+    FitsHeaderEntry,
+    FocuserState,
+    ICalibrate,
+    IFitsHeaderBefore,
+    IFocuser,
+    IPointingRaDec,
+    IRotation,
+    RaDecState,
+    RotationState,
+)
 from pyobs.mixins import FitsNamespaceMixin, MotionStatusMixin
 from pyobs.modules import Module, timeout
 from pyobs.utils.enums import MotionStatus
 from pyobs.utils.parallel import event_wait
 from pyobs.utils.threads import LockWithAbort
-from pyobs.interfaces import IRotation, IMotion, IFocuser, ICalibrate, IFitsHeaderBefore, IPointingRaDec
 from pyobs.utils.time import Time
 
-from .geminidriver import GeminiDriver, GeminiCommException, Vocab
+from .geminidriver import GeminiCommException, GeminiDriver, Vocab
 
 log = logging.getLogger(__name__)
 
@@ -33,8 +43,8 @@ class GeminiFocuserRotator(
 
     def __init__(
         self,
-        serial_config: Optional[Dict[str, Any]] = None,
-        fits_config: Optional[Dict[str, Any]] = None,
+        serial_config: dict[str, Any] | None = None,
+        fits_config: dict[str, Any] | None = None,
         focus_offset: float = 0.0,
         rotation_offset: float = 0.0,
         *args: Any,
@@ -60,7 +70,7 @@ class GeminiFocuserRotator(
         # ROTATOR STUFF
         self._rotation_lock = asyncio.Lock()
         self._rotation_abort = asyncio.Event()
-        self._skycoord: Optional[SkyCoord] = None
+        self._skycoord: SkyCoord | None = None
         self._rotation_accur = 0.0  # DEG
         self._rotation_offset = rotation_offset
 
@@ -78,7 +88,7 @@ class GeminiFocuserRotator(
             self._serial_config = serial_config
 
         # driver
-        self._driver: Optional[GeminiDriver] = None
+        self._driver: GeminiDriver | None = None
 
         # FITS HEADER CONFIGURATION
         if fits_config is None:
@@ -111,8 +121,7 @@ class GeminiFocuserRotator(
         # subscribe to events
         if self.comm:
             if self.follow:
-                # self.comm.register_event(TelescopeMovingEvent, self._telescope_event)
-                self.comm.register_event(MotionStatusChangedEvent, self._telescope_event)
+                await self.comm.register_event(MotionStatusChangedEvent, self._telescope_event)
 
         # create driver and open it
         self._driver = GeminiDriver(**self._serial_config)
@@ -198,11 +207,15 @@ class GeminiFocuserRotator(
             # TODO: find out
             # self._T = fdict.response[Vocab.CURRENT_TEMP.value]
 
+            # publish current focus/rotation state
+            await self.comm.set_state(IFocuser, FocuserState(focus=self.focus, focus_offset=self._focus_offset))
+            await self.comm.set_state(IRotation, RotationState(rotation=self.rotation))
+
             # get motion status
             await self._change_motion_status(self._motion_status(fdict.response), interface="IFocuser")
             await self._change_motion_status(self._motion_status(rdict.response), interface="IRotation")
 
-    def _motion_status(self, stat: Dict[str, Any]) -> MotionStatus:
+    def _motion_status(self, stat: dict[str, Any]) -> MotionStatus:
         """
         Extracts the IMotion status from a dictionary returned
         by the driver's status method.
@@ -243,7 +256,7 @@ class GeminiFocuserRotator(
             await event_wait(self._focus_abort, 1)
             await self._update_status()
 
-            while not self._focus_abort.is_set() and await self.get_motion_status("IFocuser") == MotionStatus.SLEWING:
+            while not self._focus_abort.is_set() and self.motion_status("IFocuser") == MotionStatus.SLEWING:
                 # sleep a little
                 await event_wait(self._focus_abort, 1)
 
@@ -254,14 +267,6 @@ class GeminiFocuserRotator(
         # success
         log.info("Successfully set new focus.")
 
-    async def get_focus(self, **kwargs: Any) -> float:
-        """Return current focus.
-
-        Returns:
-            Current focus.
-        """
-        return self.focus
-
     @timeout(300000)
     async def set_rotation(self, angle: float, **kwargs: Any) -> None:
         """Sets the rotation angle to the given value in degrees."""
@@ -281,9 +286,7 @@ class GeminiFocuserRotator(
             await event_wait(self._rotation_abort, 1)
             await self._update_status()
 
-            while (
-                not self._rotation_abort.is_set() and await self.get_motion_status("IRotation") == MotionStatus.SLEWING
-            ):
+            while not self._rotation_abort.is_set() and self.motion_status("IRotation") == MotionStatus.SLEWING:
                 # sleep a little
                 await event_wait(self._rotation_abort, 1)
 
@@ -294,11 +297,7 @@ class GeminiFocuserRotator(
         # success
         log.info("Successfully set new rotation.")
 
-    async def get_rotation(self, **kwargs: Any) -> float:
-        """Returns the current rotation angle."""
-        return await self._driver.get_rotation()
-
-    async def stop_motion(self, device: Optional[str] = None, **kwargs: Any) -> None:
+    async def stop_motion(self, device: str | None = None, **kwargs: Any) -> None:
         """Stop the motion.
 
         Args:
@@ -320,7 +319,7 @@ class GeminiFocuserRotator(
 
         # valid coordinates?
         if ra < 0.0 or ra > 360.0 or np.abs(dec) >= 90.0:
-            raise ValueError("RA, Dec out of limits (%.2f, %.2f)." % (ra, dec))
+            raise ValueError(f"RA, Dec out of limits ({ra:.2f}, {dec:.2f}).")
         skycoord = SkyCoord(ra * u.deg, dec * u.deg, frame="icrs")
 
         # get parallactic angle
@@ -331,14 +330,12 @@ class GeminiFocuserRotator(
 
         # start tracking and log it
         self._skycoord = skycoord
+        await self.comm.set_state(IPointingRaDec, RaDecState(ra=ra, dec=dec))
         log.info(
             "Started target tracking of parallactic angle at %s...",
             self._skycoord.to_string(),
         )
 
-    async def get_radec(self, **kwargs: Any) -> Tuple[float, float]:
-        return 0.0, 0.0
-
     async def _rotation_tracker_func(self) -> None:
         if self._driver is None:
             return
@@ -352,11 +349,8 @@ class GeminiFocuserRotator(
                 # get parallactic angle
                 pa = self.observer.parallactic_angle(Time.now(), self._skycoord).degree
 
-                # get rotation
-                rot = await self.get_rotation()
-
-                # need to rotate?
-                if np.abs(pa - rot) > self._rotation_accur:
+                # need to rotate? (self.rotation is kept fresh by _gdriver_update_func)
+                if np.abs(pa - self.rotation) > self._rotation_accur:
                     # rotate
                     await self._driver.set_rotation(pa + self._rotation_offset)
 
@@ -364,8 +358,8 @@ class GeminiFocuserRotator(
             await asyncio.sleep(1)
 
     async def get_fits_header_before(
-        self, namespaces: Optional[List[str]] = None, **kwargs: Any
-    ) -> Dict[str, Tuple[Any, str]]:
+        self, namespaces: list[str] | None = None, **kwargs: Any
+    ) -> dict[str, FitsHeaderEntry]:
         """Returns FITS header for the current status of this module.
 
         Args:
@@ -374,34 +368,34 @@ class GeminiFocuserRotator(
         Returns:
             Dictionary containing FITS headers.
         """
-        hdr = {}
+        hdr: dict[str, FitsHeaderEntry] = {}
 
         # SET FOCUS HEADERS
         if "focus" in self._fits_config:
             key, comment = self._fits_config["focus"]
-            hdr[key] = self.focus, comment
+            hdr[key] = FitsHeaderEntry(value=self.focus, comment=comment)
         if "focus-motion" in self._fits_config:
             key, comment = self._fits_config["focus-motion"]
-            hdr[key] = (await self.get_motion_status("IFocuser")).value, comment
+            hdr[key] = FitsHeaderEntry(value=self.motion_status("IFocuser").value, comment=comment)
         if "focus-offset" in self._fits_config:
             key, comment = self._fits_config["focus-offset"]
-            hdr[key] = self._focus_offset, comment
+            hdr[key] = FitsHeaderEntry(value=self._focus_offset, comment=comment)
 
         # SET ROTATION HEADERS
         if "rotation" in self._fits_config:
             key, comment = self._fits_config["rotation"]
-            hdr[key] = self.rotation, comment
+            hdr[key] = FitsHeaderEntry(value=self.rotation, comment=comment)
         if "rotation-motion" in self._fits_config:
             key, comment = self._fits_config["rotation-motion"]
-            hdr[key] = (await self.get_motion_status("IRotation")).value, comment
+            hdr[key] = FitsHeaderEntry(value=self.motion_status("IRotation").value, comment=comment)
         if "rotation-offset" in self._fits_config:
             key, comment = self._fits_config["rotation-offset"]
-            hdr[key] = self._rotation_offset, comment
+            hdr[key] = FitsHeaderEntry(value=self._rotation_offset, comment=comment)
 
         # TEMPERATURE SENSOR
         if "temperature" in self._fits_config:
             key, comment = self._fits_config["temperature"]
-            hdr[key] = self._T, comment
+            hdr[key] = FitsHeaderEntry(value=self._T, comment=comment)
 
         # return it
         return self._filter_fits_namespace(hdr, namespaces=namespaces, **kwargs)
@@ -418,14 +412,6 @@ class GeminiFocuserRotator(
         """
         pass
 
-    async def get_focus_offset(self, **kwargs: Any) -> float:
-        """Return current focus offset.
-
-        Returns:
-            Current focus offset.
-        """
-        return 0.0
-
     async def init(self, **kwargs: Any) -> None:
         """Initialize device.
 
@@ -442,19 +428,11 @@ class GeminiFocuserRotator(
         """
         pass
 
-    async def is_ready(self, **kwargs: Any) -> bool:
-        """Returns the device is "ready", whatever that means for the specific device.
-
-        Returns:
-            Whether device is ready
-        """
-        return True
-
     async def _telescope_event(self, ev: Event, sender: str) -> bool:
         """Moving events from telescope.
 
         Args:
-            event: Either a MotionStatusChangedEvent or a TelescopeMovingEvent.
+            event: A MotionStatusChangedEvent.
             sender: Who sent it.
         """
 
@@ -462,23 +440,8 @@ class GeminiFocuserRotator(
         if self.follow is None or self.follow != sender:
             return False
 
-        # what kind of event is it?
-        if isinstance(ev, TelescopeMovingEvent):
-            # do we have RA/Dec?
-            if ev.ra is not None and ev.dec is not None:
-                # start tracking!
-                log.info("Received an event that telescope is about to start tracking. Following it... ")
-                await self.track(ev.ra, ev.dec)
-
-            else:
-                # presumably slewing to fixed coordinates
-                # are we currently tracking?
-                if self._skycoord is not None:
-                    log.info("Received event that telescope is not tracking anymore, stopping derotator movement...")
-                    await self.stop_motion("IRotation")
-
-        elif isinstance(ev, MotionStatusChangedEvent):
-            # we want the ITelescope event and anything except TRACKING and SLEWING (might end up in race condition)
+        # we want the ITelescope event and anything except TRACKING and SLEWING (might end up in race condition)
+        if isinstance(ev, MotionStatusChangedEvent):
             if "ITelescope" in ev.interfaces and ev.interfaces["ITelescope"] not in [
                 MotionStatus.TRACKING.value,
                 MotionStatus.SLEWING.value,
@@ -489,5 +452,7 @@ class GeminiFocuserRotator(
                     log.info("Received event that telescope is not tracking anymore, stopping derotator movement...")
                     await self.stop_motion("IRotation")
 
+        return True
+
 
 __all__ = ["GeminiFocuserRotator"]

{pyobs_gemini-1.0.1 → pyobs_gemini-2.0.0.dev1}/pyobs_gemini/geminidriver.py

@@ -1,13 +1,14 @@
 import asyncio
-import enum
 import datetime
+import enum
 import logging
-from typing import Optional, Any, Dict, List, cast
-import numpy as np
-import aioserial
 from itertools import chain
+from typing import Any, cast
+
+import aioserial
+import numpy as np
 
-from pyobs_gemini.api import gemini_commands, gemini_cmd, gemini_parse_output
+from pyobs_gemini.api import gemini_cmd, gemini_commands, gemini_parse_output
 
 log = logging.getLogger(__name__)
 
@@ -16,20 +17,20 @@ class GeminiTransaction:
     def __init__(
         self,
         tid: int = 0,
-        cmd: Optional[str] = None,
-        raw_cmd: Optional[str] = None,
-        response: Optional[Dict[str, Any]] = None,
-        errors: Optional[Dict[str, Any]] = None,
+        cmd: str | None = None,
+        raw_cmd: str | None = None,
+        response: dict[str, Any] | None = None,
+        errors: dict[str, Any] | None = None,
     ):
         """Constructor for a gemini transaction dictionary"""
         self.transaction = {"id": tid, "cmd": cmd, "raw_cmd": raw_cmd}
         self.response = {} if response is None else response
         self.errors = {} if errors is None else errors
         self.time = datetime.datetime.now()
-        self.data: Dict[Vocab, Any] = {}
+        self.data: dict[Vocab, Any] = {}
 
 
-def has_transaction_error(d: Optional[GeminiTransaction], keys: Optional[List[str]] = None) -> bool:
+def has_transaction_error(d: GeminiTransaction | None, keys: list[str] | None = None) -> bool:
     """Is there a problem with this transaction dictionary?"""
     if d is None:
         return True
@@ -42,7 +43,7 @@ def has_transaction_error(d: Optional[GeminiTransaction], keys: Optional[List[st
         return False
 
 
-def dict_union(*args: Any) -> Dict[str, Any]:
+def dict_union(*args: Any) -> dict[str, Any]:
     return dict(chain.from_iterable(d.items() for d in args if d is not None))
 
 
@@ -96,11 +97,11 @@ class GeminiDriver:
         self._lock = asyncio.Lock()
 
         # init
-        self._serial: Optional[aioserial.AioSerial] = None
+        self._serial: aioserial.AioSerial | None = None
         self.transID = 0
         self.transactions = np.array([None for i in range(99)], dtype=dict)  # CIRCULAR BUFFER
-        self.focus_model: Optional[Dict[str, float]] = None
-        self.rotation_model: Optional[Dict[str, float]] = None
+        self.focus_model: dict[str, float] | None = None
+        self.rotation_model: dict[str, float] | None = None
         self.focus_offset = 0.0
         self.rotation_offset = 0.0
 
@@ -233,9 +234,7 @@ class GeminiDriver:
 
         # conversion between hardware and position angle: deg = offset + scale * millideg
         # 	native is 0-360000 milli-degrees, convert to -180 to +180 degrees
-        min_rsteps = 0
         max_rsteps = 360000
-        rrange = 360.0  # DEG
         self.rotation_model = {
             "offset": -180.0,
             "scale": 0.001,
@@ -384,7 +383,7 @@ class GeminiDriver:
             await self._send_to_gemini("F", "DOHOME")
             return True
         except GeminiCommException as e:
-            log.error("Could not home focus: " + str(e))
+            log.error("Could not home focus: %s", e)
             return False
 
     async def focus_is_homed(self) -> bool:
@@ -407,7 +406,7 @@ class GeminiDriver:
             await self._send_to_gemini("R", "DOHOME")
             return True
         except GeminiCommException as e:
-            log.error("Could not home rotation: " + str(e))
+            log.error("Could not home rotation: %s", e)
             return False
 
     async def rotation_is_homed(self) -> bool:

pyobs_gemini-2.0.0.dev1/pyproject.toml

@@ -0,0 +1,46 @@
+[project]
+name = "pyobs-gemini"
+version = "2.0.0.dev1"
+description = "pyobs module for Optec Gemini focusser/rotator"
+authors = [
+    { name = "Tim-Oliver Husser", email = "thusser@uni-goettingen.de" },
+    { name = "Frederic V. Hessman", email = "fhessma@uni-goettingen.de" },
+]
+requires-python = ">=3.11,<3.14"
+license = "MIT"
+dependencies = [
+    "aioserial>=1.3,<2",
+    "astropy>=7.0.1,<8",
+    "numpy>=2.2.5,<3",
+    "pyobs-core>=2.0.0.dev38,<3",
+]
+
+[dependency-groups]
+dev = [
+    "black>=25.1.0,<26",
+    "pre-commit>=4.2.0,<5",
+    "ruff>=0.9.0",
+    "pyrefly>=1.1.1",
+]
+
+[tool.uv.build-backend]
+module-root = ""
+
+[build-system]
+requires = ["uv_build>=0.9.14,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.black]
+line-length = 120
+target-version = ['py311']
+
+[tool.ruff]
+target-version = "py311"
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "G"]
+
+[tool.pyrefly]
+python-version = "3.11"
+ignore-missing-imports = []

pyobs_gemini-1.0.1/LICENSE

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Tim-Oliver Husser, Frederic V. Hessman
-thusser@uni-goettingen.de
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

pyobs_gemini-1.0.1/PKG-INFO

@@ -1,16 +0,0 @@
-Metadata-Version: 2.1
-Name: pyobs-gemini
-Version: 1.0.1
-Summary: pyobs module for Optec Gemini focusser/rotator
-License: MIT
-Author: Tim-Oliver Husser
-Author-email: thusser@uni-goettingen.de
-Requires-Python: >=3.9,<3.12
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Requires-Dist: aioserial (>=1.3,<2.0)
-Requires-Dist: astropy (>=5.1,<6.0)
-Requires-Dist: pyobs-core (>=1.0,<2.0)

pyobs_gemini-1.0.1/pyobs_gemini/__init__.py

@@ -1 +0,0 @@
-from .gemini import GeminiFocuserRotator

pyobs_gemini-1.0.1/pyproject.toml

@@ -1,24 +0,0 @@
-[tool.poetry]
-name = "pyobs-gemini"
-version = "1.0.1"
-description = "pyobs module for Optec Gemini focusser/rotator"
-authors = ["Tim-Oliver Husser <thusser@uni-goettingen.de>", "Frederic V. Hessman <fhessma@uni-goettingen.de>"]
-license = "MIT"
-
-[tool.poetry.dependencies]
-python = ">=3.9,<3.12"
-astropy = "^5.1"
-aioserial = "^1.3"
-pyobs-core = "^1.0"
-
-[tool.poetry.dev-dependencies]
-black = "^21.12b0"
-pre-commit = "^2.16"
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"
-
-[tool.black]
-line-length = 120
-target-version = ['py39']