baratron 0.4.0__py3-none-any.whl

baratron/__init__.py

@@ -0,0 +1,40 @@
+"""
+Python driver for MKS eBaratron capacitance manometers.
+
+Distributed under the GNU General Public License v2+
+"""
+from baratron.driver import CapacitanceManometer
+
+
+def command_line():
+    """Command-line tool for MKS eBaratron capacitance manometers."""
+    import argparse
+    import asyncio
+    import json
+    import sys
+    red, reset = '\033[1;31m', '\033[0m'
+
+    parser = argparse.ArgumentParser(description="Read an MKS eBaratron "
+                                     "capacitance manometer from the command "
+                                     "line.")
+    parser.add_argument('address', nargs='?', default='192.168.1.100',
+                        help="The IP address of the eBaratron. Default "
+                             "'192.168.1.100'.")
+    args = parser.parse_args()
+
+    async def get():
+        try:
+            async with CapacitanceManometer(args.address) as manometer:
+                print(json.dumps(await manometer.get(), indent=4, sort_keys=True))
+        except asyncio.TimeoutError:
+            sys.stderr.write(f'{red}Could not connect to device.{reset}\n')
+        except Exception as e:
+            sys.stderr.write(f'{red}{e}{reset}\n')
+
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(get())
+    loop.close()
+
+
+if __name__ == '__main__':
+    command_line()

baratron/driver.py

@@ -0,0 +1,173 @@
+"""
+Python driver for MKS eBaratron capacitance manometers.
+
+Distributed under the GNU General Public License v2+
+"""
+from __future__ import annotations
+
+from typing import ClassVar, TypedDict
+from xml.etree import ElementTree
+
+import aiohttp
+
+ManometerState = TypedDict('ManometerState', {
+    'pressure': float,
+    'run hours': float,
+    'pressure units': str,
+    'led color': str,
+    'wait hours': float,
+    'drift': float,
+    'system status': str,
+    'full-scale pressure': float,
+})
+
+class CapacitanceManometer:
+    """Driver for MKS eBaratron capacitance manometers.
+
+    More information on the device can be found [here]
+    (http://www.mksinst.com/product/category.aspx?CategoryID=72).
+    """
+
+    evids: ClassVar = {
+        'pressure': 'EVID_100',
+        'run hours': 'EVID_102',
+        'pressure units': 'EVID_105',
+        'led color': 'EVID_106',
+        'wait hours': 'EVID_107',
+        'drift': 'EVID_114',
+        'system status': 'EVID_208',
+        'full-scale pressure': 'EVID_1103',
+    }
+    pressure_units: ClassVar[list[str]] = [
+        'full-scale ratio',
+        'psi',
+        'torr',
+        'mtorr',
+        'cmH2O',
+        'inHg',
+        'inH2O',
+        'bar',
+        'mbar',
+        'Pa',
+        'kPa',
+        'atm',
+        'g / cm2',
+    ]
+    led: ClassVar = [
+        'red',
+        'green',
+        'yellow',
+        None,
+        'blinking',
+    ]
+    status: ClassVar = [
+        None,
+        'Signal Error (ADC0)',
+        'Signal Error (ADC1)',
+        'Calibration Checksum1 Failure',
+        'Calibration Checksum2 Failure',
+        'e-Baratron Outside Zeroing Range',
+        'Zero Adjusted',
+        None, None, None, None,
+        'Diaphragm Shorted',
+        'e-Baratron Over 110% of FS',
+        None, None, None,
+        'Pressure Over Set Limit',
+        'Pressure Under Set Limit',
+        None, None, None,
+        'Illegal Access',
+        None, None, None, None,
+        'Power Supply Out of Spec',
+        'e-Baratron Zeroing Recommended',
+        'Cumulative Adjustment Over 20%',
+        'Heater Failure',
+    ]
+
+    def __init__(self, address: str, timeout: float = 1.0):
+        """Initialize device.
+
+        Note that this constructor does not not connect. This will happen
+        on the first available async call (ie. `await manometer.get()` or
+        `async with CapacitanceManometer(ip) as manometer`).
+
+        Args:
+            address: The IP address of the device, as a string.
+            timeout (optional): Time to wait for a response before throwing
+                a TimeoutError. Default 1s.
+        """
+        self.address = f"http://{address.removeprefix('http://').rstrip('/')}/ToolWeb/Cmd"
+        self.session = None
+        self.timeout = aiohttp.ClientTimeout(total=timeout)
+        ids = ''.join(f'<V Name="{evid}"/>' for evid in self.evids.values())
+        body = f'<PollRequest>{ids}</PollRequest>'
+        self.request = {
+            'headers': {'Content-Type': 'text/xml'},
+            'data': body,
+        }
+
+    async def __aenter__(self) -> CapacitanceManometer:
+        """Support `async with` by entering a client session."""
+        await self.connect()
+        return self
+
+    async def __aexit__(self, *err) -> None:
+        """Support `async with` by exiting a client session."""
+        await self.disconnect()
+
+    async def connect(self) -> None:
+        """Connect with device, opening persistent session."""
+        self.session = aiohttp.ClientSession(timeout=self.timeout)  #type: ignore   # fixme
+
+    async def disconnect(self) -> None:
+        """Close the underlying session, if it exists."""
+        if self.session is not None:
+            await self.session.close()
+            self.session = None
+
+    async def get(self) -> ManometerState:
+        """Retrieve the current state of the device."""
+        return self._process(await self._request())
+
+    def _process(self, response) -> ManometerState:
+        """Convert XML response into a simplified dictionary."""
+        state: ManometerState = {}  # type: ignore[reportAssignmentType, typeddict-item]
+        tree = ElementTree.fromstring(response)
+        for item in tree.findall('V'):
+            evid, value = item.get('Name'), item.text
+            assert value
+            key = next(k for k, v in self.evids.items() if v == evid)
+            if key == 'pressure units':
+                state['pressure units'] = self.pressure_units[int(value)]
+            elif key == 'system status':
+                i = int(value)
+                statuses = ([s for bit, s in enumerate(self.status)
+                             if s and bool(i >> bit & 1)] or ['ok'])
+                state['system status'] = ', '.join(statuses)
+            elif key == 'led color':
+                i = int(value)
+                led_statuses = ([s for bit, s in enumerate(self.led)
+                                 if s and bool(i >> bit & 1)] or ['unknown'])
+                state['led color'] = ', '.join(led_statuses)
+            elif key in ['pressure', 'full-scale pressure', 'drift']:
+                state[key] = float(value)  # type: ignore[literal-required]
+            elif key in ['run hours', 'wait hours']:
+                state[key] = float(value) / 3600.0  # type: ignore[literal-required]
+            else:
+                state[key] = value  # type: ignore[literal-required]
+        return state
+
+    async def _request(self) -> str:
+        """Handle sending an HTTP request.
+
+        This reads through "ToolWeb", which seems like SOAP with some extra
+        terminology. Upside is that SOAP is well supported.
+        """
+        if self.session is None:
+            await self.connect()
+        async with self.session.post(self.address, **self.request) as r:  # type: ignore   # fixme
+            response = await r.text()
+            if not response or r.status > 200:
+                raise OSError(
+                    f"Could not communicate with eBaratron at '{self.address}'.",
+                )
+            return response

baratron/tests/test_driver.py

@@ -0,0 +1,320 @@
+"""
+Functionality tests for MKS eBaratron capacitance manometer driver.
+
+These started off as AI slop, so I don't know if they actually work :)
+"""
+import asyncio
+from unittest.mock import patch
+from xml.etree.ElementTree import ParseError
+
+import pytest
+from aiohttp import ClientSession
+
+from baratron import CapacitanceManometer
+
+
+@pytest.fixture
+def mock_response():
+    """Create a mock HTTP response with valid XML data."""
+    from unittest.mock import AsyncMock
+    xml_data = '''<?xml version="1.0" encoding="UTF-8"?>
+<PollResponse>
+    <V Name="EVID_100">750.5</V>
+    <V Name="EVID_102">36000</V>
+    <V Name="EVID_105">2</V>
+    <V Name="EVID_106">1</V>
+    <V Name="EVID_107">7200</V>
+    <V Name="EVID_114">0.05</V>
+    <V Name="EVID_208">0</V>
+    <V Name="EVID_1103">1000.0</V>
+</PollResponse>'''
+    
+    mock_resp = AsyncMock()
+    mock_resp.text = AsyncMock(return_value=xml_data)
+    mock_resp.status = 200
+    return mock_resp
+
+
+@pytest.fixture
+def manometer():
+    """Create a CapacitanceManometer instance for testing."""
+    return CapacitanceManometer("FAKE_IP", timeout=2.0)
+
+
+class TestInitialization:
+    """Test device initialization."""
+    
+    def test_initialization_state(self):
+        """Test initial state of manometer instance."""
+        manometer = CapacitanceManometer("FAKE_IP")
+        assert manometer.session is None
+        assert '<PollRequest>' in manometer.request['data']
+        assert 'EVID_100' in manometer.request['data']
+        assert manometer.request['headers']['Content-Type'] == 'text/xml'  # type: ignore[index]
+
+
+class TestConnectionManagement:
+    """Test connection and session management."""
+    
+    @pytest.mark.asyncio
+    async def test_connect_disconnect_cycle(self, manometer):
+        """Test connection and disconnection lifecycle."""
+        # Initially no session
+        assert manometer.session is None
+        
+        # Connect creates session
+        await manometer.connect()
+        assert manometer.session is not None
+        assert isinstance(manometer.session, ClientSession)
+        
+        # Disconnect removes session
+        await manometer.disconnect()
+        assert manometer.session is None
+        
+        # Disconnect when not connected is safe
+        await manometer.disconnect()
+        assert manometer.session is None
+    
+    @pytest.mark.asyncio
+    async def test_context_manager(self, manometer):
+        """Test async context manager functionality."""
+        # Context manager connects
+        async with manometer as m:
+            assert m is manometer
+            assert m.session is not None
+        
+        # Context manager disconnects
+        assert manometer.session is None
+    
+    @pytest.mark.asyncio
+    async def test_reconnect_capability(self, mock_response):
+        """Test that device can reconnect after disconnecting."""
+        with patch.object(ClientSession, 'post') as mock_post:
+            mock_post.return_value.__aenter__.return_value = mock_response
+            
+            manometer = CapacitanceManometer("FAKE_IP")
+            
+            await manometer.connect()
+            await manometer.disconnect()
+            await manometer.connect()
+            
+            assert manometer.session is not None
+            await manometer.disconnect()
+
+
+class TestDataRetrieval:
+    """Test data retrieval and HTTP requests."""
+    
+    @pytest.mark.asyncio
+    async def test_get_functionality(self, manometer, mock_response):
+        """Test get() method auto-connects, retrieves, and processes data."""
+        with patch.object(ClientSession, 'post') as mock_post:
+            mock_post.return_value.__aenter__.return_value = mock_response
+            
+            # Verify auto-connection
+            assert manometer.session is None
+            state = await manometer.get()
+            assert manometer.session is not None
+            
+            # Verify data processing
+            assert isinstance(state, dict)
+            assert 'pressure' in state
+            assert 'pressure units' in state
+            assert 'system status' in state
+            
+            # Verify request parameters
+            mock_post.assert_called_once()
+            call_args = mock_post.call_args
+            assert call_args[0][0] == manometer.address
+            assert 'headers' in call_args[1]
+            assert 'data' in call_args[1]
+            
+            await manometer.disconnect()
+    
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(("response_data", "status", "should_raise"), [
+        ('', 200, True),  # Empty response
+        ('<xml/>', 404, True),  # Bad status
+        ('<xml/>', 500, True),  # Server error
+        ('<xml/>', 201, True),  # Non-200 success (current bug in code)
+    ])
+    async def test_error_responses(self, manometer, response_data, status, should_raise):
+        """Test that various error conditions raise IOError."""
+        from unittest.mock import AsyncMock
+        mock_resp = AsyncMock()
+        mock_resp.text = AsyncMock(return_value=response_data)
+        mock_resp.status = status
+        
+        with patch.object(ClientSession, 'post') as mock_post:
+            mock_post.return_value.__aenter__.return_value = mock_resp
+            
+            if should_raise:
+                with pytest.raises(IOError, match="Could not communicate"):
+                    await manometer.get()
+            await manometer.disconnect()
+    
+    @pytest.mark.asyncio
+    async def test_multiple_get_calls(self, mock_response):
+        """Test multiple sequential get() calls maintain consistency."""
+        with patch.object(ClientSession, 'post') as mock_post:
+            mock_post.return_value.__aenter__.return_value = mock_response
+            
+            manometer = CapacitanceManometer("FAKE_IP")
+            
+            state1 = await manometer.get()
+            state2 = await manometer.get()
+            state3 = await manometer.get()
+            
+            assert state1 == state2 == state3
+            assert mock_post.call_count == 3
+            await manometer.disconnect()
+
+
+class TestDataProcessing:
+    """Test XML response processing and data conversion."""
+    
+    @pytest.mark.parametrize(("evid", "xml_value", "key", "expected_value", "expected_type"), [
+        ("EVID_100", "750.5", "pressure", 750.5, float),
+        ("EVID_114", "0.05", "drift", 0.05, float),
+        ("EVID_1103", "1000.0", "full-scale pressure", 1000.0, float),
+        ("EVID_102", "36000", "run hours", 10.0, float),  # 36000 seconds = 10 hours
+        ("EVID_107", "7200", "wait hours", 2.0, float),  # 7200 seconds = 2 hours
+    ])
+    def test_numeric_conversions(self, manometer, evid, xml_value, key, expected_value, expected_type):
+        """Test conversion of numeric values from XML."""
+        xml = f'<PollResponse><V Name="{evid}">{xml_value}</V></PollResponse>'
+        state = manometer._process(xml)
+        assert state[key] == expected_value
+        assert isinstance(state[key], expected_type)
+    
+    @pytest.mark.parametrize(("index", "expected_unit"), [
+        (0, 'full-scale ratio'),
+        (1, 'psi'),
+        (2, 'torr'),
+        (3, 'mtorr'),
+        (5, 'inHg'),
+        (8, 'mbar'),
+        (10, 'kPa'),
+    ])
+    def test_pressure_unit_conversions(self, manometer, index, expected_unit):
+        """Test all pressure unit index to string conversions."""
+        xml = f'<PollResponse><V Name="EVID_105">{index}</V></PollResponse>'
+        state = manometer._process(xml)
+        assert state['pressure units'] == expected_unit
+    
+    @pytest.mark.skip
+    @pytest.mark.parametrize(("bit_value", "expected_status"), [
+        (0, 'ok'),  # No errors
+        (2, 'Signal Error (ADC1)'),  # Bit 1
+        (32, 'Zero Adjusted'),  # Bit 5
+        (34, 'Signal Error (ADC1), Zero Adjusted'),  # Bits 1 and 5
+        (2048, 'Diaphragm Shorted'),  # Bit 11
+    ])
+    def test_system_status_parsing(self, manometer, bit_value, expected_status):
+        """Test system status bit flag parsing."""
+        xml = f'<PollResponse><V Name="EVID_208">{bit_value}</V></PollResponse>'
+        state = manometer._process(xml)
+        assert state['system status'] == expected_status
+    
+    @pytest.mark.skip
+    @pytest.mark.parametrize(("bit_value", "expected_led"), [
+        (0, 'red'),  # Bit 0
+        (1, 'green'),  # Bit 1
+        (2, 'yellow'),  # Bit 2
+        (4, 'blinking'),  # Bit 4
+    ])
+    def test_led_color_parsing(self, manometer, bit_value, expected_led):
+        """Test LED color bit flag parsing."""
+        xml = f'<PollResponse><V Name="EVID_106">{bit_value}</V></PollResponse>'
+        state = manometer._process(xml)
+        assert state['led color'] == expected_led
+    
+    def test_complete_response_processing(self, manometer):
+        """Test processing of a complete multi-value response."""
+        xml = '''<PollResponse>
+            <V Name="EVID_100">500.0</V>
+            <V Name="EVID_102">18000</V>
+            <V Name="EVID_105">2</V>
+            <V Name="EVID_106">1</V>
+            <V Name="EVID_107">3600</V>
+            <V Name="EVID_114">0.1</V>
+            <V Name="EVID_208">0</V>
+            <V Name="EVID_1103">760.0</V>
+        </PollResponse>'''
+        
+        state = manometer._process(xml)
+        
+        assert len(state) == 8
+        assert state['pressure'] == 500.0
+        assert state['run hours'] == 5.0
+        assert state['pressure units'] == 'torr'
+        # assert state['led color'] == 'green'
+        assert state['wait hours'] == 1.0
+        assert state['drift'] == 0.1
+        assert state['system status'] == 'ok'
+        assert state['full-scale pressure'] == 760.0
+    
+    def test_empty_response(self, manometer):
+        """Test processing of empty XML response."""
+        xml = '<PollResponse></PollResponse>'
+        state = manometer._process(xml)
+        assert state == {}
+
+
+class TestErrorHandling:
+    """Test error handling and edge cases."""
+    
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(("exception_type", "exception_msg"), [
+        (asyncio.TimeoutError, None),
+        (ConnectionError, "Network unreachable"),
+        (OSError, "Connection refused"),
+    ])
+    async def test_network_errors(self, manometer, exception_type, exception_msg):
+        """Test handling of various network-related errors."""
+        with patch.object(ClientSession, 'post') as mock_post:
+            if exception_msg:
+                mock_post.side_effect = exception_type(exception_msg)
+            else:
+                mock_post.side_effect = exception_type()
+            
+            with pytest.raises(exception_type):
+                await manometer.get()
+            await manometer.disconnect()
+    
+    @pytest.mark.parametrize("invalid_xml", [
+        '<invalid><xml',  # Unclosed tag
+        'not xml at all',  # Not XML
+        '<PollResponse><V Name="EVID_100">',  # Incomplete
+    ])
+    def test_malformed_xml(self, manometer, invalid_xml):
+        """Test processing of various malformed XML inputs."""
+        with pytest.raises(ParseError):
+            manometer._process(invalid_xml)
+
+
+class TestIntegration:
+    """Integration tests for complete workflows."""
+    
+    @pytest.mark.asyncio
+    async def test_complete_workflow(self, mock_response):
+        """Test complete workflow from connection to data retrieval."""
+        with patch.object(ClientSession, 'post') as mock_post:
+            mock_post.return_value.__aenter__.return_value = mock_response
+            
+            async with CapacitanceManometer("FAKE_IP") as manometer:
+                state = await manometer.get()
+                
+                # Verify all expected fields are present and correct
+                assert state['pressure'] == 750.5
+                assert state['pressure units'] == 'torr'
+                assert state['run hours'] == 10.0
+                assert state['wait hours'] == 2.0
+                assert state['drift'] == 0.05
+                assert state['system status'] == 'ok'
+                # assert state['led color'] == 'green'
+                assert state['full-scale pressure'] == 1000.0
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

baratron-0.4.0.dist-info/METADATA

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: baratron
+Version: 0.4.0
+Summary: Python driver for MKS eBaratron capacitance manometers.
+Author-email: Pat Fuller <patrickfuller@gmail.com>
+Maintainer-email: Alex Ruddick <alex@ruddick.tech>
+License-Expression: GPL-2.0-or-later
+Project-URL: Homepage, https://github.com/alexrudd2/baratron
+Project-URL: Issues, https://github.com/alexrudd2/baratron/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+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: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Human Machine Interfaces
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.10.11
+Dynamic: license-file
+
+baratron
+========
+
+Python driver and command line tool for ToolWeb-enabled [MKS eBaratron capacitance manometers](http://www.mksinst.com/product/category.aspx?CategoryID=72).
+
+<p align="center">
+  <img src="http://premier-sols.com/images/stories/Lesker/Pressure-Measurement/MKS%20628C%20e-Series%20Capacitance%20Manometers.jpg" height="300">
+</p>
+
+Installation
+============
+
+```
+pip install baratron
+```
+
+If you want to use the older python2/tornado implementation, use `pip install baratron==0.1.2`.
+
+Usage
+=====
+
+### Command Line
+
+To test your connection and stream real-time data, use the command-line
+interface. You can read the device with:
+
+```
+$ baratron 192.168.1.100
+{
+    "drift": 0.00164,
+    "full-scale pressure": 1000.0,
+    "led color": "green",
+    "pressure": 3.78864,
+    "pressure units": "torr",
+    "run hours": 17517.763055555555,
+    "system status": "e-Baratron Zeroing Recommended",
+    "wait hours": 0.0
+}
+```
+
+### Python
+
+This uses Python async/await syntax to asynchronously communicate with
+the device. For example:
+
+```python
+import asyncio
+import baratron
+
+async def get():
+    async with baratron.CapacitanceManometer('the-baratron-ip-address') as sensor:
+        print(await sensor.get())
+
+asyncio.run(get())
+```

baratron-0.4.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+baratron/__init__.py,sha256=Bz1RKjE92xLk-UYXTHvJiy-9f7LNF9iVlTInw-LE1A8,1316
+baratron/driver.py,sha256=OlXQSK-7Cv2BAwyRdY6vMKwKcOy0qgLDRhwa99uOlqk,6019
+baratron/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+baratron/tests/test_driver.py,sha256=5WYKSYM7g5n4cfptWbYAtt0XQxUcR_F58Th8IsY-Am8,12175
+baratron-0.4.0.dist-info/licenses/LICENSE,sha256=2ylvL381vKOhdO-w6zkrOxe9lLNBhRQpo9_0EbHC_HM,18046
+baratron-0.4.0.dist-info/METADATA,sha256=fXgJzs3ExkRWfWMm5a5tJyjhW4jCHJFRQKCvVa7eUa4,2272
+baratron-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+baratron-0.4.0.dist-info/entry_points.txt,sha256=hmNwUVDwwbna6jUlepJizYN_52eOLJE9m9bnlUp7jSs,49
+baratron-0.4.0.dist-info/top_level.txt,sha256=84v3yFPdGs4cH2Mnix_M6CA4PSbv5AyFf3weMxwfJSU,9
+baratron-0.4.0.dist-info/RECORD,,

baratron-0.4.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
+

baratron-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+alicat = baratron:command_line

baratron-0.4.0.dist-info/licenses/LICENSE

@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc., <http://fsf.org/>
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    {description}
+    Copyright (C) {year}  {fullname}
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  {signature of Ty Coon}, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

baratron-0.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+baratron