ka9q-python 3.2.0__py3-none-any.whl

ka9q/types.py

@@ -0,0 +1,161 @@
+"""
+ka9q-radio protocol types and constants
+
+Status types from ka9q-radio/src/status.h
+These MUST match the enum values in status.h exactly!
+Verified against https://github.com/ka9q/ka9q-radio (official repository)
+"""
+
+class StatusType:
+    """TLV type identifiers for radiod status/control protocol"""
+    
+    EOL = 0
+    COMMAND_TAG = 1
+    CMD_CNT = 2
+    GPS_TIME = 3
+    
+    DESCRIPTION = 4
+    STATUS_DEST_SOCKET = 5
+    SETOPTS = 6
+    CLEAROPTS = 7
+    RTP_TIMESNAP = 8
+    UNUSED4 = 9
+    INPUT_SAMPRATE = 10
+    UNUSED6 = 11
+    UNUSED7 = 12
+    INPUT_SAMPLES = 13
+    UNUSED8 = 14
+    UNUSED9 = 15
+    
+    OUTPUT_DATA_SOURCE_SOCKET = 16
+    OUTPUT_DATA_DEST_SOCKET = 17
+    OUTPUT_SSRC = 18
+    OUTPUT_TTL = 19
+    OUTPUT_SAMPRATE = 20
+    OUTPUT_METADATA_PACKETS = 21
+    OUTPUT_DATA_PACKETS = 22
+    OUTPUT_ERRORS = 23
+    
+    # Hardware
+    CALIBRATE = 24
+    LNA_GAIN = 25
+    MIXER_GAIN = 26
+    IF_GAIN = 27
+    
+    DC_I_OFFSET = 28
+    DC_Q_OFFSET = 29
+    IQ_IMBALANCE = 30
+    IQ_PHASE = 31
+    DIRECT_CONVERSION = 32
+    
+    # Tuning
+    RADIO_FREQUENCY = 33
+    FIRST_LO_FREQUENCY = 34
+    SECOND_LO_FREQUENCY = 35
+    SHIFT_FREQUENCY = 36
+    DOPPLER_FREQUENCY = 37
+    DOPPLER_FREQUENCY_RATE = 38
+    
+    # Filtering
+    LOW_EDGE = 39
+    HIGH_EDGE = 40
+    KAISER_BETA = 41
+    FILTER_BLOCKSIZE = 42
+    FILTER_FIR_LENGTH = 43
+    FILTER2 = 44
+    
+    # Signals
+    IF_POWER = 45
+    BASEBAND_POWER = 46
+    NOISE_DENSITY = 47
+    
+    # Demodulation configuration
+    DEMOD_TYPE = 48  # 0 = linear (default), 1 = FM, 2 = WFM/Stereo, 3 = spectrum
+    OUTPUT_CHANNELS = 49  # 1 or 2 in Linear, otherwise 1
+    INDEPENDENT_SIDEBAND = 50  # Linear only
+    PLL_ENABLE = 51
+    PLL_LOCK = 52
+    PLL_SQUARE = 53
+    PLL_PHASE = 54
+    PLL_BW = 55
+    ENVELOPE = 56
+    SNR_SQUELCH = 57
+    
+    # Demodulation status
+    PLL_SNR = 58  # FM, PLL linear
+    FREQ_OFFSET = 59
+    PEAK_DEVIATION = 60
+    PL_TONE = 61
+    
+    # Settable gain parameters
+    AGC_ENABLE = 62  # Boolean, linear modes only
+    HEADROOM = 63
+    AGC_HANGTIME = 64
+    AGC_RECOVERY_RATE = 65
+    FM_SNR = 66
+    AGC_THRESHOLD = 67
+    
+    GAIN = 68  # AM, Linear only
+    OUTPUT_LEVEL = 69
+    OUTPUT_SAMPLES = 70
+    
+    OPUS_BIT_RATE = 71
+    MINPACKET = 72
+    FILTER2_BLOCKSIZE = 73
+    FILTER2_FIR_LENGTH = 74
+    FILTER2_KAISER_BETA = 75
+    SPECTRUM_FFT_N = 76
+    
+    FILTER_DROPS = 77
+    LOCK = 78
+    
+    TP1 = 79  # Test points
+    TP2 = 80
+    
+    GAINSTEP = 81
+    AD_BITS_PER_SAMPLE = 82
+    SQUELCH_OPEN = 83
+    SQUELCH_CLOSE = 84
+    PRESET = 85  # Mode/preset name (e.g., "iq", "usb", "lsb")
+    DEEMPH_TC = 86
+    DEEMPH_GAIN = 87
+    CONVERTER_OFFSET = 88
+    PL_DEVIATION = 89
+    THRESH_EXTEND = 90
+    
+    # Spectral analysis
+    SPECTRUM_KAISER_BETA = 91
+    COHERENT_BIN_SPACING = 92
+    NONCOHERENT_BIN_BW = 93
+    BIN_COUNT = 94
+    CROSSOVER = 95
+    BIN_DATA = 96
+    
+    RF_ATTEN = 97
+    RF_GAIN = 98
+    RF_AGC = 99
+    FE_LOW_EDGE = 100
+    FE_HIGH_EDGE = 101
+    FE_ISREAL = 102
+    BLOCKS_SINCE_POLL = 103
+    AD_OVER = 104
+    RTP_PT = 105
+    STATUS_INTERVAL = 106
+    OUTPUT_ENCODING = 107
+    SAMPLES_SINCE_OVER = 108
+    PLL_WRAPS = 109
+    RF_LEVEL_CAL = 110
+
+
+# Command packet type
+CMD = 1
+
+# Encoding types (from ka9q-radio)
+class Encoding:
+    """Output encoding types"""
+    NO_ENCODING = 0
+    S16BE = 1  # Signed 16-bit big-endian
+    S16LE = 2  # Signed 16-bit little-endian
+    F32 = 3    # 32-bit float
+    F16 = 4    # 16-bit float
+    OPUS = 5   # Opus codec

ka9q/utils.py

@@ -0,0 +1,202 @@
+"""
+Shared utility functions for ka9q-python
+
+This module contains common utilities used across the package, primarily
+for mDNS address resolution and network operations.
+"""
+
+import socket
+import subprocess
+import re
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+def resolve_multicast_address(address: str, timeout: float = 5.0) -> str:
+    """
+    Resolve hostname or mDNS address to IP for multicast operations
+    
+    This function tries multiple resolution methods for cross-platform compatibility:
+    1. Check if already an IP address (no resolution needed)
+    2. Try avahi-resolve (Linux)
+    3. Try dns-sd (macOS)
+    4. Fallback to getaddrinfo (works everywhere)
+    
+    Args:
+        address: Hostname, .local mDNS name, or IP address
+        timeout: Resolution timeout in seconds (default: 5.0)
+        
+    Returns:
+        Resolved IP address as string (e.g., "239.251.200.193")
+        
+    Raises:
+        Exception: If resolution fails after trying all methods
+        
+    Example:
+        >>> resolve_multicast_address("radiod.local")
+        '239.251.200.193'
+        
+        >>> resolve_multicast_address("192.168.1.100")
+        '192.168.1.100'
+    """
+    # Check if already an IP address
+    if re.match(r'^\d+\.\d+\.\d+\.\d+$', address):
+        logger.debug(f"Address {address} is already an IP")
+        return address
+    
+    # Try avahi-resolve (Linux)
+    try:
+        result = subprocess.run(
+            ['avahi-resolve', '-n', address],
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        if result.returncode == 0:
+            # Parse output: "hostname    ip_address"
+            parts = result.stdout.strip().split()
+            if len(parts) >= 2:
+                resolved = parts[1]
+                logger.debug(f"Resolved via avahi-resolve: {address} -> {resolved}")
+                return resolved
+    except (subprocess.TimeoutExpired, FileNotFoundError) as e:
+        logger.debug(f"avahi-resolve not available: {e}")
+    
+    # Try dns-sd (macOS)
+    try:
+        result = subprocess.run(
+            ['dns-sd', '-G', 'v4', address],
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        if result.returncode == 0:
+            # Parse dns-sd output for IP address
+            for line in result.stdout.split('\n'):
+                # Look for lines containing the address and an IP
+                match = re.search(r'(\d+\.\d+\.\d+\.\d+)', line)
+                if match and address in line:
+                    resolved = match.group(1)
+                    logger.debug(f"Resolved via dns-sd: {address} -> {resolved}")
+                    return resolved
+    except (subprocess.TimeoutExpired, FileNotFoundError) as e:
+        logger.debug(f"dns-sd not available: {e}")
+    
+    # Fallback to getaddrinfo (works everywhere)
+    # Note: getaddrinfo doesn't support timeout, so we set socket default timeout
+    try:
+        old_timeout = socket.getdefaulttimeout()
+        socket.setdefaulttimeout(timeout)
+        try:
+            addr_info = socket.getaddrinfo(address, None, socket.AF_INET, socket.SOCK_DGRAM)
+            resolved = addr_info[0][4][0]
+            logger.debug(f"Resolved via getaddrinfo: {address} -> {resolved}")
+            return resolved
+        finally:
+            socket.setdefaulttimeout(old_timeout)
+    except Exception as e:
+        raise Exception(f"Failed to resolve {address}: {e}") from e
+
+
+def create_multicast_socket(multicast_addr: str, port: int = 5006, 
+                            bind_addr: str = '0.0.0.0',
+                            interface: Optional[str] = None) -> socket.socket:
+    """
+    Create and configure a UDP socket for multicast operations
+    
+    This is a convenience function that sets up all the necessary socket options
+    for sending to or receiving from a multicast group.
+    
+    Args:
+        multicast_addr: Multicast group IP address
+        port: Port number (default: 5006 for radiod)
+        bind_addr: Address to bind to (default: '0.0.0.0' for all interfaces)
+        interface: IP address of network interface for multicast membership
+                  (e.g., '192.168.1.100'). Required on multi-homed systems.
+                  If None, uses INADDR_ANY (0.0.0.0).
+        
+    Returns:
+        Configured socket ready for multicast operations
+        
+    Raises:
+        OSError: If socket creation or configuration fails
+        
+    Example:
+        >>> sock = create_multicast_socket('239.251.200.193')
+        >>> sock.sendto(data, ('239.251.200.193', 5006))
+        
+        >>> # Multi-homed system
+        >>> sock = create_multicast_socket('239.251.200.193', interface='192.168.1.100')
+    """
+    import struct
+    
+    # Create UDP socket
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    
+    # Allow multiple sockets to bind to the same port
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    
+    # Set SO_REUSEPORT if available (allows multiple processes)
+    if hasattr(socket, 'SO_REUSEPORT'):
+        try:
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+            logger.debug("SO_REUSEPORT enabled")
+        except OSError as e:
+            logger.debug(f"Could not set SO_REUSEPORT: {e}")
+    
+    # Bind to specified port
+    try:
+        sock.bind((bind_addr, port))
+        logger.debug(f"Bound to {bind_addr}:{port}")
+    except OSError as e:
+        logger.error(f"Failed to bind socket to {bind_addr}:{port}: {e}")
+        sock.close()
+        raise
+    
+    # Join multicast group on specified interface
+    interface_addr = interface if interface else '0.0.0.0'
+    mreq = struct.pack('=4s4s',
+                      socket.inet_aton(multicast_addr),  # multicast group
+                      socket.inet_aton(interface_addr))  # interface to use
+    try:
+        sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
+        logger.debug(f"Joined multicast group {multicast_addr} on interface {interface_addr}")
+    except OSError as e:
+        # EADDRINUSE is not fatal - group already joined
+        if e.errno != 48:  # EADDRINUSE on macOS
+            logger.warning(f"Failed to join multicast group: {e}")
+    
+    return sock
+
+
+def validate_multicast_address(address: str) -> bool:
+    """
+    Validate that an address is a valid multicast address
+    
+    Multicast addresses are in the range 224.0.0.0 to 239.255.255.255
+    
+    Args:
+        address: IP address string to validate
+        
+    Returns:
+        True if valid multicast address, False otherwise
+        
+    Example:
+        >>> validate_multicast_address('239.251.200.193')
+        True
+        
+        >>> validate_multicast_address('192.168.1.1')
+        False
+    """
+    try:
+        parts = address.split('.')
+        if len(parts) != 4:
+            return False
+        
+        first_octet = int(parts[0])
+        # Multicast range: 224.0.0.0 to 239.255.255.255
+        return 224 <= first_octet <= 239
+    except (ValueError, AttributeError):
+        return False

ka9q_python-3.2.0.dist-info/METADATA

@@ -0,0 +1,237 @@
+Metadata-Version: 2.4
+Name: ka9q-python
+Version: 3.2.0
+Summary: Python interface for ka9q-radio control and monitoring
+Home-page: https://github.com/mijahauan/ka9q-python
+Author: Michael Hauan AC0G
+Author-email: Michael Hauan AC0G <ac0g@hauan.org>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mijahauan/ka9q-python
+Project-URL: Documentation, https://github.com/mijahauan/ka9q-python/blob/main/README.md
+Project-URL: Repository, https://github.com/mijahauan/ka9q-python
+Project-URL: Issues, https://github.com/mijahauan/ka9q-python/issues
+Keywords: ka9q-radio,sdr,ham-radio,radio-control
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Telecommunications Industry
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications :: Ham Radio
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# ka9q-python
+
+[![PyPI version](https://badge.fury.io/py/ka9q-python.svg)](https://badge.fury.io/py/ka9q-python)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**General-purpose Python library for controlling [ka9q-radio](https://github.com/ka9q/ka9q-radio)**
+
+Control radiod channels for any application: AM/FM/SSB radio, WSPR monitoring, SuperDARN radar, CODAR oceanography, HF fax, satellite downlinks, and more.
+
+**Note:** Package name is `ka9q-python` out of respect for KA9Q (Phil Karn's callsign). Import as `import ka9q`.
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Documentation](#documentation)
+- [Examples](#examples)
+- [Use Cases](#use-cases)
+- [License](#license)
+
+## Features
+
+✅ **Zero assumptions** - Works for any SDR application  
+✅ **Complete API** - All 85+ radiod parameters exposed  
+✅ **Channel control** - Create, configure, discover channels  
+✅ **RTP recording** - Generic recorder with timing support and state machine  
+✅ **Precise timing** - GPS_TIME/RTP_TIMESNAP for accurate timestamps  
+✅ **Multi-homed support** - Works on systems with multiple network interfaces  
+✅ **Pure Python** - No compiled dependencies  
+✅ **Well tested** - Comprehensive test coverage  
+✅ **Documented** - Comprehensive examples and API reference included  
+
+## Installation
+
+```bash
+pip install ka9q-python
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/mijahauan/ka9q-python.git
+cd ka9q-python
+pip install -e .
+```
+
+## Quick Start
+
+### Listen to AM Broadcast
+
+```python
+from ka9q import RadiodControl
+
+# Connect to radiod
+control = RadiodControl("radiod.local")
+
+# Create AM channel on 10 MHz WWV
+control.create_channel(
+    ssrc=10000000,
+    frequency_hz=10.0e6,
+    preset="am",
+    sample_rate=12000
+)
+
+# RTP stream now available with SSRC 10000000
+```
+
+### Monitor WSPR Bands
+
+```python
+from ka9q import RadiodControl
+
+control = RadiodControl("radiod.local")
+
+wspr_bands = [
+    (1.8366e6, "160m"),
+    (3.5686e6, "80m"),
+    (7.0386e6, "40m"),
+    (10.1387e6, "30m"),
+    (14.0956e6, "20m"),
+]
+
+for freq, band in wspr_bands:
+    control.create_channel(
+        ssrc=int(freq),
+        frequency_hz=freq,
+        preset="usb",
+        sample_rate=12000
+    )
+    print(f"{band} WSPR channel created")
+```
+
+### Discover Existing Channels
+
+```python
+from ka9q import discover_channels
+
+channels = discover_channels("radiod.local")
+for ssrc, info in channels.items():
+    print(f"{ssrc}: {info.frequency/1e6:.3f} MHz, {info.preset}, {info.sample_rate} Hz")
+```
+
+### Record RTP Stream with Precise Timing
+
+```python
+from ka9q import discover_channels, RTPRecorder
+import time
+
+# Get channel with timing info
+channels = discover_channels("radiod.local")
+channel = channels[14074000]
+
+# Define packet handler
+def handle_packet(header, payload, wallclock):
+    print(f"Packet at {wallclock}: {len(payload)} bytes")
+
+# Create and start recorder
+recorder = RTPRecorder(channel=channel, on_packet=handle_packet)
+recorder.start()
+recorder.start_recording()
+time.sleep(60)  # Record for 60 seconds
+recorder.stop_recording()
+recorder.stop()
+```
+
+### Multi-Homed Systems
+
+For systems with multiple network interfaces, specify which interface to use:
+
+```python
+from ka9q import RadiodControl, discover_channels
+
+# Specify your interface IP address
+my_interface = "192.168.1.100"
+
+# Create control with specific interface
+control = RadiodControl("radiod.local", interface=my_interface)
+
+# Discovery on specific interface
+channels = discover_channels("radiod.local", interface=my_interface)
+```
+
+## Documentation
+
+For detailed information, please refer to the documentation in the `docs/` directory:
+
+- **[API Reference](docs/API_REFERENCE.md)**: Full details on all classes, methods, and functions.
+- **[RTP Timing Support](docs/RTP_TIMING_SUPPORT.md)**: Guide to RTP timing and synchronization.
+- **[Architecture](docs/ARCHITECTURE.md)**: Overview of the library's design and structure.
+- **[Installation Guide](docs/INSTALLATION.md)**: Detailed installation instructions.
+- **[Testing Guide](docs/TESTING_GUIDE.md)**: Information on how to run the test suite.
+- **[Security Considerations](docs/SECURITY.md)**: Important security information regarding the ka9q-radio protocol.
+- **[Changelog](docs/CHANGELOG.md)**: A log of all changes for each version.
+- **[Release Notes](docs/releases/)**: Release-specific notes and instructions.
+
+## Examples
+
+See the `examples/` directory for complete applications:
+
+- **`discover_example.py`** - Channel discovery methods (native Python and control utility)
+- **`tune.py`** - Interactive channel tuning utility (Python implementation of ka9q-radio's tune)
+- **`tune_example.py`** - Programmatic examples of using the tune() method
+- **`rtp_recorder_example.py`** - Complete RTP recorder with timing and state machine
+- **`test_timing_fields.py`** - Verify GPS_TIME/RTP_TIMESNAP timing fields
+- **`simple_am_radio.py`** - Minimal AM broadcast listener
+- **`superdarn_recorder.py`** - Ionospheric radar monitoring
+- **`codar_oceanography.py`** - Ocean current radar
+- **`hf_band_scanner.py`** - Dynamic frequency scanner
+- **`wspr_monitor.py`** - Weak signal propagation reporter
+
+## Use Cases
+
+### AM/FM/SSB Radio
+- Broadcast monitoring
+- Ham radio operation  
+- Shortwave listening
+
+### Scientific Research
+- WSPR propagation studies
+- SuperDARN ionospheric radar
+- CODAR ocean current mapping
+- Meteor scatter
+- EME (moonbounce)
+
+### Digital Modes
+- FT8/FT4 monitoring
+- RTTY/PSK decoding
+- DRM digital radio
+- HF fax reception
+
+### Satellite Operations
+- Downlink reception
+- Doppler tracking
+- Multi-frequency monitoring
+
+### Custom Applications
+**No assumptions!** Use for anything SDR-related.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

ka9q_python-3.2.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+ka9q/__init__.py,sha256=Hj9-RXpUlYCKCaS8s_mCI2E_rT1Tb9j04fT94PSpqg8,2272
+ka9q/control.py,sha256=gte-8p8W_l76OJbaUu3pi4gqwztS1Kc1NzdMvgkoAlw,88910
+ka9q/discovery.py,sha256=gURq2GlV49vArYCcExarsKtyD1x6Is2LuDfLWveYM5c,18707
+ka9q/exceptions.py,sha256=_P8rok_tTmRMu-lLRhS95kv8FRK5PEY80_6jIux2mWM,474
+ka9q/resequencer.py,sha256=o31Hrt1m12jFyfIOtpHlICK0EQm5wm2Bo3yJNgr8FgQ,14084
+ka9q/rtp_recorder.py,sha256=J9cWygxe7oKG5nQu4tIO6Ba5gaY5iK5PahvfdpcZbo4,16171
+ka9q/stream.py,sha256=fc2yPQanVEA3FO7-jWfhEuN9UHpE9sFyybaIOOfSJHY,13822
+ka9q/stream_quality.py,sha256=yklim5rx2U_y1ElgYrLtftSxYxPItoOwIHJsw17xujA,7589
+ka9q/types.py,sha256=LtqDQIG6N89iAKuqwdwJEtupcJeLqpqRCjpRtdK0pW4,3524
+ka9q/utils.py,sha256=fFR_sYIpeDyPaFlXzN6jCiGhYlssvrMMVx4z6vyhqcc,7107
+ka9q_python-3.2.0.dist-info/licenses/LICENSE,sha256=mjz-l5TVsO9j7Jqt1gfLvTWtZK_HL9sZRRpsHaq4Qv8,1074
+ka9q_python-3.2.0.dist-info/METADATA,sha256=Rx3b6-JleiGIYvLQc7MBTE3vgIyogrdLCggj0OPA-t0,7334
+ka9q_python-3.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ka9q_python-3.2.0.dist-info/top_level.txt,sha256=FUTLZDtQpJGenGPPlN34E5QpQi_oaiLB6LuzgHblBNE,5
+ka9q_python-3.2.0.dist-info/RECORD,,

ka9q_python-3.2.0.dist-info/WHEEL

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

ka9q_python-3.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Michael James Hauan
+
+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 OF THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ka9q_python-3.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ka9q