o

�
b)o�@s�
dZd
dl
mZ
d
dlmZ
d
dlmZmZ
d
dlm	Z	
d
dl
mZmZ
d
dl
mZ
d
dlmZ
d	Zd
ZdZGdd
�d
e�ZGdd�de�Ze	ej�
Gdd�d��
ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGd d!�d!e�Z Gd"d#�d#e�Z!Gd$d%�d%e�Z"Gd&d'�d'�Z#e	ej$�
Gd(d)�d)��
Z%Gd*d+�d+e%�Z&gd,�
Z'd-S).z1
Generic positioning base classes.

@since: 14.0
�)
�partial)
�
attrgetter)�ClassVar�Sequence)
�implementer)�
NamedConstant�Names)
�ipositioning)
�FancyEqMixing��2Tv�?gr�q��?g����ׁ�?c
@�(eZ
dZd
Ze�Ze�Ze�Ze�ZdS)�Anglesa�

    The types of angles.

    @cvar LATITUDE: Angle representing a latitude of an object.
    @type LATITUDE: L{NamedConstant}

    @cvar LONGITUDE: Angle representing the longitude of an object.
    @type LONGITUDE: L{NamedConstant}

    @cvar HEADING: Angle representing the heading of an object.
    @type HEADING: L{NamedConstant}

    @cvar VARIATION: Angle representing a magnetic variation.
    @type VARIATION: L{NamedConstant}

    N)	�__name__�
__module__�__qualname__�__doc__r�LATITUDE�	LONGITUDE�HEADING�	VARIATION�rr�:/usr/lib/python3/dist-packages/twisted/positioning/base.pyrs




rc
@r)�
DirectionszB
    The four cardinal directions (north, east, south, west).
    N)	r
rrrr�NORTH�EAST�SOUTH�WESTrrrrr3s




rc@sPeZ
dZd
Zdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�ZdS)�BasePositioningReceiveraS

    A base positioning receiver.

    This class would be a good base class for building positioning
    receivers. It implements the interface (so you don't have to) with stub
    methods.

    People who want to implement positioning receivers should subclass this
    class and override the specific callbacks they want to handle.
    c
C�d
S)zG
        Implements L{IPositioningReceiver.timeReceived} stub.
        Nr)�self�timerrr�timeReceivedK�z$BasePositioningReceiver.timeReceivedc
Cr)zJ
        Implements L{IPositioningReceiver.headingReceived} stub.
        Nr)r�headingrrr�headingReceivedPr!z'BasePositioningReceiver.headingReceivedc
Cr)zH
        Implements L{IPositioningReceiver.speedReceived} stub.
        Nr�r�speedrrr�
speedReceivedUr!z%BasePositioningReceiver.speedReceivedc
Cr)zH
        Implements L{IPositioningReceiver.climbReceived} stub.
        Nr�r�climbrrr�
climbReceivedZr!z%BasePositioningReceiver.climbReceivedc
Cr)zK
        Implements L{IPositioningReceiver.positionReceived} stub.
        Nr)r�latitude�	longituderrr�positionReceived_r!z(BasePositioningReceiver.positionReceivedc
Cr)zP
        Implements L{IPositioningReceiver.positionErrorReceived} stub.
        Nr)r�
positionErrorrrr�positionErrorReceiveddr!z-BasePositioningReceiver.positionErrorReceivedc
Cr)zK
        Implements L{IPositioningReceiver.altitudeReceived} stub.
        Nr�r�altituderrr�altitudeReceivedir!z(BasePositioningReceiver.altitudeReceivedc
Cr)zT
        Implements L{IPositioningReceiver.beaconInformationReceived} stub.
        Nr)r�beaconInformationrrr�beaconInformationReceivednr!z1BasePositioningReceiver.beaconInformationReceivedN)r
rrrr r#r&r)r,r.r1r3rrrrr>src
@�eZ
dZd
ZdS)�InvalidSentencez9
    An exception raised when a sentence is invalid.
    N�r
rrrrrrrr5t�
r5c
@r4)�InvalidChecksumzI
    An exception raised when the checksum of a sentence is invalid.
    Nr6rrrrr8zr7r8c	@s�eZ
dZUd
Zejdd�ejdd�ejdd�ejdd�iZ	ejdejdejd	ejd
iZ
dZee
eed<ddd�
Zedd��
Zedd��
Zdd�Zdd�Zdefdd�Zedd��
Zedd��
Zd
S) �Anglea�

    An object representing an angle.

    @cvar _RANGE_EXPRESSIONS: A collection of expressions for the allowable
        range for the angular value of a particular coordinate value.
    @type _RANGE_EXPRESSIONS: C{dict} of L{Angles} constants to callables
    @cvar _ANGLE_TYPE_NAMES: English names for angle types.
    @type _ANGLE_TYPE_NAMES: C{dict} of L{Angles} constants to C{str}
    c

C�d
|ko	dkS
S)Ng�V�g�V@r)
r*rrr�<lambda>��zAngle.<lambda>c

Cr:)Ng�f�g�f@r)
r+rrrr;�r<c

Csd
|k
o	dkS
S)Nr
�h
r)
r"rrrr;�r<c

Csd
|ko	dk
S
S)NiL����r)
�	variationrrrr;�r<�Latitude�	Longitude�	Variation�Heading)�	angleType�inDecimalDegrees�compareAttributesNcCs`|d
u
r
||jv
r
t
d�
�
|
d
u
r(|d
u
r(|j|}||
�
s(d}t
|�|
|��
�
||_|
|_d
S)aG
        Initializes an angle.

        @param angle: The value of the angle in decimal degrees. (L{None} if
            unknown).
        @type angle: C{float} or L{None}

        @param angleType: A symbolic constant describing the angle type. Should
            be one of L{Angles} or {None} if unknown.

        @raises ValueError: If the angle type is not the default argument,
            but it is an unknown type (not in  C{Angle._RANGE_EXPRESSIONS}),
            or it is a known type but the supplied value was out of the
            allowable range for said type.
        NzUnknown angle typez+Angle {0} not in allowed range for type {1})�_RANGE_EXPRESSIONS�
ValueError�formatrD�_angle)r�anglerD�rangeExpression�templaterrr�__init__�s







zAngle.__init__c


C�|jS)
z�
        The value of this angle in decimal degrees. This value is immutable.

        @return: This angle expressed in decimal degrees, or L{None} if the
            angle is unknown.
        @rtype: C{float} (or L{None})
        �
rJ�
rrrrrE��	zAngle.inDecimalDegreesc
Csb|jd
urd
St
t|j�
�
}
t
|jt|j�
�
}d|}t|�
}|t|�
}d|}|
|t|�
fS)a

        The value of this angle as a degrees, minutes, seconds tuple. This
        value is immutable.

        @return: This angle expressed in degrees, minutes, seconds. L{None} if
            the angle is unknown.
        @rtype: 3-C{tuple} of C{int} (or L{None})
        N�<)rJ�abs�int)r�degrees�fractionalDegrees�decimalMinutes�minutes�fractionalMinutes�decimalSecondsrrr�inDegreesMinutesSeconds�s






zAngle.inDegreesMinutesSecondscCs(|
d
v
r
td|
�
�
|
t
|j�
|_dS)a

        Sets the sign of this angle.

        @param sign: The new sign. C{1} for positive and C{-1} for negative
            signs, respectively.
        @type sign: C{int}

        @raise ValueError: If the C{sign} parameter is not C{-1} or C{1}.
        )����
z#bad sign (got %s, expected -1 or 1)N)rHrTrJ�r�signrrr�setSign�s

z
Angle.setSignc


CrO)
z�
        Returns this angle as a float.

        @return: The float value of this angle, expressed in degrees.
        @rtype: C{float}
        rPrQrrr�	__float__��zAngle.__float__�returnc

Csd
j|d�
S)��
        Returns a string representation of this angle.

        @return: The string representation.
        @rtype: C{str}
        z.<{s._angleTypeNameRepr} ({s._angleValueRepr})>�
�
s�
rIrQrrr�__repr__�szAngle.__repr__c

Cs|jd
u
r
dt
|jd�SdS)z�
        Returns a string representation of the angular value of this angle.

        This is a helper function for the actual C{__repr__}.

        @return: The string representation.
        @rtype: C{str}
        Nz
%s degrees�z
unknown value)rE�roundrQrrr�_angleValueRepr�s


zAngle._angleValueReprc

Cs$z|j|j
WSty


Yd
Sw)z�
        Returns a string representation of the type of this angle.

        This is a helper function for the actual C{__repr__}.

        @return: The string representation.
        @rtype: C{str}
        zAngle of unknown type)�_ANGLE_TYPE_NAMESrD�KeyErrorrQrrr�_angleTypeNameRepr
s




�zAngle._angleTypeNameRepr�NN)r
rrrrrrrrrGrmrFrr�str�__annotations__rN�propertyrEr\rarbrirlrorrrrr9�s2








�


�





		


r9c@sZeZ
dZd
Zddd�
Zeddd�
�
Zedd��
Zd	d
�Z	e
ej�
dg
Zde
fd
d�ZdS)rCa�
    The heading of a mobile object.

    @ivar variation: The (optional) magnetic variation.
        The sign of the variation is positive for variations towards the east
        (clockwise from north), and negative for variations towards the west
        (counterclockwise from north).
        If the variation is unknown or not applicable, this is L{None}.
    @type variation: C{Angle} or L{None}.
    @ivar correctedHeading: The heading, corrected for variation. If the
        variation is unknown (L{None}), is None. This attribute is read-only
        (its value is determined by the angle and variation attributes). The
        value is coerced to being between 0 (inclusive) and 360 (exclusive).
    NcCst�
||
tj�
||_d
S)zB
        Initializes an angle with an optional variation.
        N)r9rNrrr?)rrKr?rrrrN,
s

zHeading.__init__cCst|t
j�}||
|�S)
a_

        Constructs a Heading from the float values of the angle and variation.

        @param angleValue: The angle value of this heading.
        @type angleValue: C{float}
        @param variationValue: The value of the variation of this heading.
        @type variationValue: C{float}
        @return: A L{Heading} with the given values.
        )r9rr)�cls�
angleValue�variationValuer?rrr�
fromFloats3
s

zHeading.fromFloatsc
Cs6|jd
us
|j
d
urd
S|j|j
jd}
t|
tj�S)a

        Corrects the heading by the given variation. This is sometimes known as
        the true heading.

        @return: The heading, corrected by the variation. If the variation or
            the angle are unknown, returns L{None}.
        @rtype: C{float} or L{None}
        Nr=)rJr?rEr9rr)rrKrrr�correctedHeadingA
s


zHeading.correctedHeadingcCs$|jj
d
ur
td�
�
|j�|
�

d
S)a

        Sets the sign of the variation of this heading.

        @param sign: The new sign. C{1} for positive and C{-1} for negative
            signs, respectively.
        @type sign: C{int}

        @raise ValueError: If the C{sign} parameter is not C{-1} or C{1}.
        Nz*can't set the sign of an unknown variation)r?rErHrar_rrrraQ
s

zHeading.setSignr?rdc
Cs,|jd
urd}
nt
|j�
}
d�|j|j|
�S)reNzunknown variationz
<{} ({}, {})>)r?�reprrIrorl)r�
variationReprrrrrib
s





�zHeading.__repr__rp)r
rrrrN�classmethodrwrsrxra�listr9rFrqrirrrrrC
s




rCc@s&eZ
dZd
Zddd�
Zedd��
ZdS)�
Coordinatea


    A coordinate.

    @ivar angle: The value of the coordinate in decimal degrees, with the usual
        rules for sign (northern and eastern hemispheres are positive, southern
        and western hemispheres are negative).
    @type angle: C{float}
    NcCs2|tj
tjd
fv
rtd�|�
�
�
t�||
|�
d
S)aM
        Initializes a coordinate.

        @param angle: The angle of this coordinate in decimal degrees. The
            hemisphere is determined by the sign (north and east are positive).
            If this coordinate describes a latitude, this value must be within
            -90.0 and +90.0 (exclusive). If this value describes a longitude,
            this value must be within -180.0 and +180.0 (exclusive).
        @type angle: C{float}
        @param coordinateType: The coordinate type. One of L{Angles.LATITUDE},
            L{Angles.LONGITUDE} or L{None} if unknown.
        NzQcoordinateType must be one of Angles.LATITUDE, Angles.LONGITUDE or None, was {!r})rrrrHrIr9rN)rrK�coordinateTyperrrrN
s



�zCoordinate.__init__c

CsL|jt
jur|jd
krtjStjS|jt
jur"|jd
krtjStj	St
d�
�
)z�
        Gets the hemisphere of this coordinate.

        @return: A symbolic constant representing a hemisphere (one of
            L{Angles})
        r
z.unknown coordinate type (cant find hemisphere))rDrrrErrrrrrrHrQrrr�
hemisphere�
s	






zCoordinate.hemisphere�
N)r
rrrrNrsrrrrrr}u
s


	
r}c@�JeZ
dZd
ZdZdd�Zedd��
Zedd��
Zd	d
�Z	de
fdd
�ZdS)�Altitudez�
    An altitude.

    @ivar inMeters: The altitude represented by this object, in meters. This
        attribute is read-only.
    @type inMeters: C{float}

    @ivar inFeet: As above, but expressed in feet.
    @type inFeet: C{float}
    )
�inMeterscC�
|
|_d
S)z}
        Initializes an altitude.

        @param altitude: The altitude in meters.
        @type altitude: C{float}
        N�
�	_altituder/rrrrN�
�
zAltitude.__init__c

C�
|jt
S)
z�
        Gets the altitude this object represents, in feet.

        @return: The altitude, expressed in feet.
        @rtype: C{float}
        )r��METERS_PER_FOOTrQrrr�inFeet�
s
zAltitude.inFeetc


CrO)
z�
        Returns the altitude this object represents, in meters.

        @return: The altitude, expressed in feet.
        @rtype: C{float}
        r�rQrrrr��
szAltitude.inMetersc


CrO)
z�
        Returns the altitude represented by this object expressed in meters.

        @return: The altitude represented by this object, expressed in meters.
        @rtype: C{float}
        r�rQrrrrb�
rczAltitude.__float__rdc

C�d
|j�d�S)z�
        Returns a string representation of this altitude.

        @return: The string representation.
        @rtype: C{str}
        z<Altitude (z m)>r�rQrrrri�
�zAltitude.__repr__N)r
rrrrFrNrsr�r�rbrqrirrrrr��
s
	

	

		r�c@r�)�
_BaseSpeedz�
    An object representing the abstract concept of the speed (rate of
    movement) of a mobile object.

    This primarily has behavior for converting between units and comparison.
    )
�inMetersPerSecondcCr�)a2

        Initializes a speed.

        @param speed: The speed that this object represents, expressed in
            meters per second.
        @type speed: C{float}

        @raises ValueError: Raised if value was invalid for this particular
            kind of speed. Only happens in subclasses.
        N�
�_speedr$rrrrN�
s
z_BaseSpeed.__init__c


CrO)
z�
        The speed that this object represents, expressed in meters per second.
        This attribute is immutable.

        @return: The speed this object represents, in meters per second.
        @rtype: C{float}
        r�rQrrrr�rRz_BaseSpeed.inMetersPerSecondc

Cr�)
z�
        Returns the speed represented by this object, expressed in knots. This
        attribute is immutable.

        @return: The speed this object represents, in knots.
        @rtype: C{float}
        )r��MPS_PER_KNOTrQrrr�inKnotss
	z_BaseSpeed.inKnotsc


CrO)
z�
        Returns the speed represented by this object expressed in meters per
        second.

        @return: The speed represented by this object, expressed in meters per
            second.
        @rtype: C{float}
        r�rQrrrrbrRz_BaseSpeed.__float__rdc
Cs"t|j
d
�}
d|jj�d|
�d�S)z�
        Returns a string representation of this speed object.

        @return: The string representation.
        @rtype: C{str}
        rj�
<z (z m/s)>)rkr��	__class__r
)r�
speedValuerrrri!s
z_BaseSpeed.__repr__N)r
rrrrFrNrsr�r�rbrqrirrrrr��
s






r�c@�eZ
dZd
Zdd�ZdS)�Speedz:
    The speed (rate of movement) of a mobile object.
    cCs&|
d
krtd|
���
�
t
�||
�
dS)z�
        Initializes a L{Speed} object.

        @param speed: The speed that this object represents, expressed in
            meters per second.
        @type speed: C{float}

        @raises ValueError: Raised if C{speed} is negative.
        r
znegative speed: N)rHr�rNr$rrrrN1s

zSpeed.__init__N�r
rrrrNrrrrr�,�
r�c@r�)�Climbz4
    The climb ("vertical speed") of an object.
    cCst�
||
�
d
S)z�
        Initializes a L{Climb} object.

        @param climb: The climb that this object represents, expressed in
            meters per second.
        @type climb: C{float}
        N)r�rNr'rrrrNFszClimb.__init__Nr�rrrrr�Ar�r�c@s�eZ
dZd
ZdZd"dd�
ZdZdd	�Zd
d�dd�gd
d�dd�gdd�dd�gd�Zdd�Z	dd�Z
edd��
Zej
dd��
Zedd��
Zej
dd��
Zedd��
Zej
dd��
ZdZdefd d!�ZdS)#�
PositionErrora#
    Position error information.

    @cvar _ALLOWABLE_THRESHOLD: The maximum allowable difference between PDOP
        and the geometric mean of VDOP and HDOP. That difference is supposed
        to be zero, but can be non-zero because of rounding error and limited
        reporting precision. You should never have to change this value.
    @type _ALLOWABLE_THRESHOLD: C{float}
    @cvar _DOP_EXPRESSIONS: A mapping of DOP types (C[hvp]dop) to a list of
        callables that take self and return that DOP type, or raise
        C{TypeError}. This allows a DOP value to either be returned directly
        if it's know, or computed from other DOP types if it isn't.
    @type _DOP_EXPRESSIONS: C{dict} of C{str} to callables
    @ivar pdop: The position dilution of precision. L{None} if unknown.
    @type pdop: C{float} or L{None}
    @ivar hdop: The horizontal dilution of precision. L{None} if unknown.
    @type hdop: C{float} or L{None}
    @ivar vdop: The vertical dilution of precision. L{None} if unknown.
    @type vdop: C{float} or L{None}
    )�pdop�hdop�vdopNFcCs$|
|_||_
||_||_|��
d
S)a�
        Initializes a positioning error object.

        @param pdop: The position dilution of precision. L{None} if unknown.
        @type pdop: C{float} or L{None}
        @param hdop: The horizontal dilution of precision. L{None} if unknown.
        @type hdop: C{float} or L{None}
        @param vdop: The vertical dilution of precision. L{None} if unknown.
        @type vdop: C{float} or L{None}
        @param testInvariant: Flag to test if the DOP invariant is valid or
            not. If C{True}, the invariant (PDOP = (HDOP**2 + VDOP**2)*.5) is
            checked at every mutation. By default, this is false, because the
            vast majority of DOP-providing devices ignore this invariant.
        @type testInvariant: c{bool}
        N)�_pdop�_hdop�_vdop�_testInvariant� _testDilutionOfPositionInvariant)rr�r�r��
testInvariantrrrrNis



zPositionError.__init__g{�G�z�?c
Csv|jsd
S|j
|j|jfD]	}
|
d
ur
d
Sq
t|j
|jd|jdd�
}||jkr9td|j
|j|jf�
�
d
S)a�

        Tests if this positioning error object satisfies the dilution of
        position invariant (PDOP = (HDOP**2 + VDOP**2)*.5), unless the
        C{self._testInvariant} instance variable is C{False}.

        @return: L{None} if the invariant was not satisfied or not tested.
        @raises ValueError: Raised if the invariant was tested but not
            satisfied.
        Nrj��?zYinvalid combination of dilutions of precision: position: %s, horizontal: %s, vertical: %s)r�r�r�r�rT�_ALLOWABLE_TRESHOLDrH)r�
x�deltarrrr��s



�"



���z.PositionError._testDilutionOfPositionInvariantc

C�
t|j
�
Sr�)�floatr�rQrrrr;��
zPositionError.<lambda>c

Cs|jd
|j
d
dS�Nrjr�)r�r�rQrrrr;�r<c

Cr�r�)r�r�rQrrrr;�r�c

C�|jd
|j
d
dSr�)r�r�rQrrrr;�r<c

Cr�r�)r�r�rQrrrr;�r�c

Cr�r�)r�r�rQrrrr;�r<c	Cs4|j|
D]}z||�
W
St
y


Yqwd
S)a,

        Gets a particular dilution of position value.

        @param dopType: The type of dilution of position to get. One of
            ('pdop', 'hdop', 'vdop').
        @type dopType: C{str}
        @return: The DOP if it is known, L{None} otherwise.
        @rtype: C{float} or L{None}
        N)�_DOP_EXPRESSIONS�	TypeError)r�dopType�
dopExpressionrrr�_getDOP�s




��zPositionError._getDOPcCsNd
|
}t||�}t
||t|�
�
z|��
WdSty&


t
|||�
�w)a�

        Sets a particular dilution of position value.

        @param dopType: The type of dilution of position to set. One of
            ('pdop', 'hdop', 'vdop').
        @type dopType: C{str}

        @param value: The value to set the dilution of position type to.
        @type value: C{float}

        If this position error tests dilution of precision invariants,
        it will be checked. If the invariant is not satisfied, the
        assignment will be undone and C{ValueError} is raised.
        �
_N)�getattr�setattrr�r�rH)rr��value�
attributeName�oldValuerrr�_setDOP�s





�zPositionError._setDOPc

C�
|�d
�
S�Nr��
r�rQrrrr���
zPositionError.pdopcC�|�d
|
�Sr��
r��rr�rrrr���c

Cr��Nr�r�rQrrrr��r�zPositionError.hdopcCr�r�r�r�rrrr��r�c

Cr��Nr�r�rQrrrr��r�zPositionError.vdopcCr�r�r�r�rrrr��r�z.<PositionError (pdop: %s, hdop: %s, vdop: %s)>rdc

Cs|j|j
|j|jfS)
z�
        Returns a string representation of positioning information object.

        @return: The string representation.
        @rtype: C{str}
        )�_REPR_TEMPLATEr�r�r�rQrrrri�szPositionError.__repr__)NNNF)r
rrrrFrNr�r�r�r�r�rsr��setterr�r�r�rqrirrrrr�Qs@


�
�
��











r�c@s(eZ
dZd
Zd	dd�
Zdefdd�ZdS)
�BeaconInformationa�
    Information about positioning beacons (a generalized term for the reference
    objects that help you determine your position, such as satellites or cell
    towers).

    @ivar seenBeacons: A set of visible beacons. Note that visible beacons are not
        necessarily used in acquiring a positioning fix.
    @type seenBeacons: C{set} of L{IPositioningBeacon}
    @ivar usedBeacons: A set of the beacons that were used in obtaining a
        positioning fix. This only contains beacons that are actually used, not
        beacons for which it is unknown if they are used or not.
    @type usedBeacons: C{set} of L{IPositioningBeacon}
    rcCst|
�
|_
t�|_d
S)z�
        Initializes a beacon information object.

        @param seenBeacons: A collection of beacons that are currently seen.
        @type seenBeacons: iterable of L{IPositioningBeacon}s
        N)�set�seenBeacons�usedBeacons)rr�rrrrNs

zBeaconInformation.__init__rdc
CsHtt
td
�
d�}
|
|j�
}|
|j|j�
}d}|jt|j�
||d�}|S)z�
        Returns a string representation of this beacon information object.

        The beacons are sorted by their identifier.

        @return: The string representation.
        @rtype: C{str}
        �
identifier)
�keyz^<BeaconInformation (used beacons ({numUsed}): {usedBeacons}, unused beacons: {unusedBeacons})>)�numUsedr��
unusedBeacons)r�sortedrr�r�rI�len)r�
sortedBeaconsr�r�rM�	formattedrrrris	

�


�zBeaconInformation.__repr__N)
r�r
rrrrNrqrirrrrr��s


r�c@s.eZ
dZd
Zdd�Zdd�Zdefdd�Zd	S)
�PositioningBeacona$

    A positioning beacon.

    @ivar identifier: The unique identifier for this beacon. This is usually
        an integer. For GPS, this is also known as the PRN.
    @type identifier: Pretty much anything that can be used as a unique
        identifier. Depends on the implementation.
    cCr�)z�
        Initializes a positioning beacon.

        @param identifier: The identifier for this beacon.
        @type identifier: Can be pretty much anything (see ivar documentation).
        N�
r�)rr�rrrrN9r�zPositioningBeacon.__init__c

Cr�)
z�
        Returns the hash of the identifier for this beacon.

        @return: The hash of the identifier. (C{hash(self.identifier)})
        @rtype: C{int}
        )�hashr�rQrrr�__hash__Br�zPositioningBeacon.__hash__rdc

Cr�)z�
        Returns a string representation of this beacon.

        @return: The string representation.
        @rtype: C{str}
        z	<Beacon (z)>r�rQrrrriKr�zPositioningBeacon.__repr__N)r
rrrrNr�rqrirrrrr�.s
			r�c@s*eZ
dZd
Z	ddd�
Zdefdd�ZdS)	�	Satellitea�

    A satellite.

    @ivar azimuth: The azimuth of the satellite. This is the heading (positive
        angle relative to true north) where the satellite appears to be to the
        device.
    @ivar elevation: The (positive) angle above the horizon where this
        satellite appears to be to the device.
    @ivar signalToNoiseRatio: The signal to noise ratio of the signal coming
        from this satellite.
    NcCs&t�
|t|
�
�
||_||_||_d
S)ar
        Initializes a satellite object.

        @param identifier: The PRN (unique identifier) of this satellite.
        @type identifier: C{int}
        @param azimuth: The azimuth of the satellite (see instance variable
            documentation).
        @type azimuth: C{float}
        @param elevation: The elevation of the satellite (see instance variable
            documentation).
        @type elevation: C{float}
        @param signalToNoiseRatio: The signal to noise ratio of the connection
            to this satellite (see instance variable documentation).
        @type signalToNoiseRatio: C{float}
        N)r�rNrU�azimuth�	elevation�signalToNoiseRatio)rr�r�r�r�rrrrNbs


zSatellite.__init__rdc
Csd
}
|
j|d�
S)z�
        Returns a string representation of this Satellite.

        @return: The string representation.
        @rtype: C{str}
        zi<Satellite ({s.identifier}), azimuth: {s.azimuth}, elevation: {s.elevation}, snr: {s.signalToNoiseRatio}>rfrh)rrMrrrrizs�zSatellite.__repr__)NNNr�rrrrr�Us


�r�)r�r9rrr�r�r}rrCr8r5r�r��MPS_PER_KPHr�r�r�r�N)(r�	functoolsr�operatorr�typingrr�zope.interfacer�
constantlyrr�twisted.positioningr	�twisted.python.utilr
r�r�r�rr�IPositioningReceiverr�	Exceptionr5r8r9rCr}r�r�r�r�r�r��IPositioningBeaconr�r��__all__rrrr�<module>
s@





5Y6>C(6
&6