degrees 0.0.1__py3-none-any.whl

degrees/__init__.py

@@ -0,0 +1,3 @@
+from .degrees import Degree, degree2radius, radius2degree, convert_to_360
+
+__all__ = ["Degree", "degree2radius", "radius2degree", "convert_to_360"]

degrees/degrees.py

@@ -0,0 +1,312 @@
+from typing import Self, Any, NoReturn, overload
+from math import radians, degrees
+
+
+class Degree:
+    @overload
+    def __init__(self, degre: int = 0, minute: int = 0, second: int = 0) -> None: ...
+    @overload
+    def __init__(self, degre: float) -> None: ...
+    @overload
+    def __init__(self, degre: Degree) -> None: ...
+    def __init__(self, degre: int | float | Degree = 0,
+                 minute: int = 0,
+                 second: int = 0) -> None:
+        """Create a degree object"""
+        self.__set_: bool
+        self.deg: int
+        self.min: int
+        self.sec: int
+
+        if isinstance(degre, Degree):
+            if minute != 0 or second != 0:
+                raise ValueError("if the type of degree is Degree, minute and second must be 0")
+            self.deg = degre.deg
+            self.min = degre.min
+            self.sec = degre.sec
+            self.sign = degre.sign
+            self.__set_ = True
+            return
+        if degre != 0:
+            if minute < 0 or second < 0:
+                raise ValueError("if degree is not 0, minute and second must be positive integer")
+            self.sign = 1 if degre > 0 else -1
+        elif minute != 0:
+            if second < 0:
+                raise ValueError("if degree is 0, but minute is not, second must be positive integer")
+            self.sign = 1 if minute > 0 else -1
+        elif second != 0:
+            self.sign = 1 if second > 0 else -1
+        else:
+            self.sign = 0
+
+        # noinspection PyTypeChecker
+        degre = abs(degre)  # type: ignore
+        minute = abs(minute)
+        second = abs(second)
+
+        self.deg = degre
+        self.min = minute
+        self.sec = second
+
+        if isinstance(degre, float):
+            self.deg = int(degre)
+            _ = abs(degre % 1)
+            self.min = int(_ * 60)
+            self.sec = int(_ * 3600 % 60)
+            self.sign = 1 if degre > 0 else -1
+
+        if isinstance(minute, float) or isinstance(second, float):
+            raise TypeError("if the type of degree is float, minute and second must be None")
+
+        if self.sec >= 60:
+            self.min += self.sec // 60
+            self.sec %= 60
+
+        if self.min >= 60:
+            if self.deg >= 0:
+                self.deg += self.min // 60
+            else:
+                self.deg -= self.min // 60
+            self.min %= 60
+        
+        if not (isinstance(self.deg, int) and isinstance(self.min, int) and isinstance(self.sec, int)):
+            raise TypeError("unknown type")
+        self.__set_ = True
+    
+    def __abs__(self) -> Self:
+        """Return the absolute value of the degree object"""
+        return Degree(abs(self.deg), abs(self.min), abs(self.sec))
+    
+    def __str__(self) -> str:
+        """Return the string form of the degree object
+        Examples:
+            Degree(1) -> 1°
+            Degree(1, 3, 5) -> 1°3'5"
+            Degree(1, 0, 5) -> 1°0'5"
+            Degree(1, 3) -> 1°3'
+            ..."""
+        r: str = "" if self.sign > 0 else "-"
+        if self.deg == self.min == self.sec == 0:
+            return "0°"
+        if self.deg != 0 and self.sec != 0:
+            return r + f"{self.deg}°{self.min}'{self.sec}\""
+        if self.deg != 0:
+            r += f"{self.deg}°"
+        if self.min != 0:
+            r += f"{self.min}'"
+        if self.sec != 0:
+            r += f'{self.sec}"'
+        return r
+
+    def __repr__(self) -> str:
+        return str(self)
+    
+    def __pos__(self) -> Self:
+        """Return self unchanged"""
+        return self
+
+    def __neg__(self) -> Self:
+        """Return self negated"""
+        if self.deg != 0:
+            return Degree(-self.deg, self.min, self.sec)
+        if self.min != 0:
+            return Degree(0, -self.min, self.sec)
+        return Degree(second=-self.sec)
+
+    def __ceil__(self) -> Self:
+        """Return the least Integral >= x"""
+        if self < Degree(0):
+            return int(self)
+        if self == Degree(0):
+            return Degree(0)
+        if not (self.min or self.sec):
+            return self.deg
+        return self.deg + 1
+
+    def __floor__(self) -> Self:
+        """Return the greatest Integral <= x"""
+        if self > Degree(0):
+            return int(self)
+        if self == Degree(0):
+            return Degree(0)
+        if not (self.min or self.sec):
+            return self.deg
+        return -self.deg - 1
+    
+    def __int__(self) -> int:
+        """Return the integer form of the degree object"""
+        return self.deg * self.sign
+    
+    def __float__(self) -> float:
+        """Return the float form of the degree object"""
+        number = (self.deg + self.min / 60 + self.sec / 3600) * self.sign
+        return float(int(number * 1000) / 1000)
+
+    def __bool__(self) -> bool:
+        """Return True if the degree object is not equal to zero, else false"""
+        if self == Degree(0):
+            return False
+        return True
+
+    def __eq__(self, other: Any) -> bool:
+        """Return self is equal to other"""
+        if isinstance(other, int):
+            return self.deg == other and self.min == 0 and self.sec == 0
+        if isinstance(other, Degree):
+            return (self.deg == other.deg and
+                    self.min == other.min and
+                    self.sec == other.sec)
+        return float(self) == other
+        
+    def __gt__(self, other: Self | int | float) -> bool:
+        """Return self is strictly greater than other"""
+        if self == other:
+            return False
+        if isinstance(other, Degree):
+            if self.sign > other.sign:
+                return True
+            if self.sign < other.sign:
+                return False
+            if self.sign + other.sign == -2:
+                if self.deg > other.deg:
+                    return False
+                if self.deg < other.deg:
+                    return True
+                if self.min > other.min:
+                    return False
+                if self.min < other.min:
+                    return True
+                return self.sec < other.sec
+            if self.sign + other.sign == 2:
+                if self.deg < other.deg:
+                    return False
+                if self.deg > other.deg:
+                    return True
+                if self.min < other.min:
+                    return False
+                if self.min > other.min:
+                    return True
+                return self.sec > other.sec
+            return False
+        if isinstance(other, int):
+            return int(self) > other
+        if isinstance(other, float):
+            return float(self) > other
+        raise TypeError("invalid type")
+
+    def __lt__(self, other: Self | int | float) -> bool:
+        """Return self is strictly less than other"""
+        return not self >= other
+
+    def __ge__(self, other: Self | int | float) -> bool:
+        """Return self is greater than or equal to other"""
+        return self > other or self == other
+
+    def __le__(self, other: Self | int | float) -> bool:
+        """Return self is less than or equal to other"""
+        return not self > other
+
+    def __ne__(self, other: Any) -> bool:
+        """Return self is not equal to other"""
+        return not self == other
+
+    def __add__(self, other: Self | int | float) -> Self:
+        """Return the sum of self and other"""
+        oth: Degree = Degree(other)
+        ttsec: int = ((self.deg * 3600 + self.min * 60 + self.sec) * self.sign +
+                      (oth.deg * 3600 + oth.min * 60 + oth.sec) * oth.sign)
+        return Degree(second=ttsec)
+
+    def __radd__(self, other: Self | int | float) -> Self:
+        """Return the sum of other and self"""
+        return self + other
+
+    def __sub__(self, other: Self | int | float) -> Self:
+        """Return the difference of self and other"""
+        return self + -other
+
+    def __rsub__(self, other: Self | int | float) -> Self:
+        """Return the difference of other and self"""
+        return -(self.__sub__(other))
+
+    def __mul__(self, other: Self | int | float) -> Self:
+        """Return the product of self and other"""
+        if isinstance(other, (int, float)):
+            tts = (self.deg * 3600 + self.min * 60 + self.sec) * self.sign * other
+            return Degree(second=tts)
+        srad = radians(self.deg + self.min / 60 + self.sec / 3600) * self.sign
+        orad = radians(other.deg + other.min / 60 + other.sec / 3600) * other.sign
+        resrad = srad * orad
+        resdeg = degrees(resrad)
+        return Degree(resdeg)
+
+    def __rmul__(self, other: Self | int | float) -> Self:
+        """Return the product of other and self"""
+        return self * other
+
+    @overload
+    def __truediv__(self, other: Self) -> float: ...
+    @overload
+    def __truediv__(self, other: int | float) -> Self: ...
+    def __truediv__(self, other: Self | int | float) -> Self | float:
+        """Return the quotient of self and other"""
+        if other == 0:
+            raise ZeroDivisionError("division by zero")
+        if isinstance(other, (int, float)):
+            tts = (self.deg * 3600 + self.min * 60 + self.sec) * self.sign // other
+            return Degree(second=tts)
+        sts = (self.deg * 3600 + self.min * 60 + self.sec) * self.sign
+        ots = (other.deg * 3600 + other.min * 60 + other.sec) * other.sign
+        return sts / ots
+
+    @overload
+    def __floordiv__(self, other: Self) -> float: ...
+    @overload
+    def __floordiv__(self, other: int | float) -> Self: ...
+    def __floordiv__(self, other: Self | int | float) -> Self | int:
+        """Return the floored quotient of self and other"""
+        if other == 0:
+            raise ZeroDivisionError("division by zero")
+        if isinstance(other, (int, float)):
+            res = self.deg * self.sign // other
+            return Degree(res)
+        sts = (self.deg * 3600 + self.min * 60 + self.sec) * self.sign
+        ots = (other.deg * 3600 + other.min * 60 + other.sec) * other.sign
+        return sts // ots
+
+    def __mod__(self, other: Self) -> Self:
+        """Return the remainder of 'self / other'"""
+        if other == Degree(0):
+            raise ZeroDivisionError("modulo by zero")
+        sts = (self.deg * 3600 + self.min * 60 + self.sec) * self.sign
+        ots = (other.deg * 3600 + other.min * 60 + other.sec) * other.sign
+        rs = sts % ots
+        return Degree(second=rs)
+
+    def __hash__(self) -> int:
+        """Return the hash value of the degree object"""
+        return hash(id(self))
+
+    def __setattr__(self, key: str, value: Any) -> None | NoReturn:
+        """Do NOT use this function, it is only used for creating a degree object"""
+        if hasattr(self, '_Degree__set_'):
+            raise AttributeError("readonly attribute")
+        else:
+            super().__setattr__(key, value)
+
+def degree2radius(x: Degree, /) -> float:
+    """Convert angle x from a degree object to radians"""
+    return radians(x.deg + x.min / 60 + x.sec / 3600)
+
+def radius2degree(x: int | float, /) -> Degree:
+    """Convert angle x from radians to a degree object"""
+    return Degree(degrees(x))
+
+def convert_to_360(x: Degree, /) -> Degree:
+    """Be using for angle normalization"""
+    tts = (x.deg * 3600 + x.min * 60 + x.sec) * x.sign
+    norms = tts % 1_296_000
+    if norms < 0:
+        norms += 1_296_000
+    return Degree(second=int(norms))

degrees-0.0.1.dist-info/METADATA

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: degrees
+Version: 0.0.1
+Summary: A python lib for degree calculations and conversions
+Author-email: ArcticChar <snake830@vip.163.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<!-- TOC -->
+* [Introduction](#introduction)
+* [Class](#class)
+* [Functions](#functions)
+  * [degree2radius](#def-degree2radiusx-degree-)
+  * [radius2degree](#def-radius2degreex-int--float-)
+  * [convert_to_360](#def-convert_to_360x-degree-)
+<!-- TOC -->
+# Introduction
+A python lib for degree calculations and conversions
+# Class
+- ## *class* degrees.Degree(degre: float)
+  ## *class* degrees.Degree(degre: Degree)
+  ## *class* degrees.Degree(degre: int = 0, minute: int = 0, second: int = 0)
+   - ### Creating a Degree object
+      ```python
+      >>> degrees.Degree(1)
+      1°
+      >>> degrees.Degree(2, 3, 4)
+      2°3'4"
+      >>> degrees.Degree(1, second=2)
+      1°0'2"
+      >>> degrees.Degree(1, 3)
+      1°3'
+     ```
+   - ### calculating:
+      
+      | `a + b`  | `a - b`        | `a * b`         | `a / b`               |
+      |----------|----------------|-----------------|-----------------------|
+      | `abs(a)` | `math.ceil(a)` | `math.floor(a)` | `a % b`               |
+      | `a // b` | `+a`           | `-a`            | `hash(a)`<sup>1</sup> |
+   - ### conversions:
+      
+      | `int(a)` | `float(a)` | `str(a)` | `repr(a)` | `bool(a)` |
+      |----------|------------|----------|-----------|-----------|
+   - ### comparisons:
+      
+      | `a >= b` | `a > b` | `a = b`  |
+      |----------|---------|----------|
+      | `a <= b` | `a < b` | `a != b` |
+   
+   > ### Note
+   > [1] `hash(Degree_object)` is equal to `hash(int(Degree_object)).`<br>
+   > [2] The attributes of Degree are read-only.
+# Functions
+## *def* degree2radius(x: Degree, /)
+   - Convert angle x from a degree object to radians.
+## *def* radius2degree(x: int | float, /)
+   - Convert angle x from radians to a degree object.
+## *def* convert_to_360(x: Degree, /)
+   - Be using for angle normalization.

degrees-0.0.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+degrees/__init__.py,sha256=2JfPtemB6jvAoYM_3Nz_IE0NRaJyI8IPwwz1-s0Ea5I,147
+degrees/degrees.py,sha256=vUz1I2TmxaOVYFy36Go5dDdYbqwdENQi39otnkPG6Gc,11676
+degrees-0.0.1.dist-info/licenses/LICENSE,sha256=oRnScbx7lo8OJ1qmfJ5vtSxh4Yah62edFNh0yveODrk,1053
+degrees-0.0.1.dist-info/METADATA,sha256=eNv9hu3l2cmnSmb235rXRIBw1OO1PhcwT1smhTdES3I,2221
+degrees-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+degrees-0.0.1.dist-info/top_level.txt,sha256=qY1E6fjp-KQmh3bW5meeW_FbGURMfk4I6jTVW0KB0HM,8
+degrees-0.0.1.dist-info/RECORD,,

degrees-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

degrees-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 ArcticChar
+
+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.

degrees-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+degrees