# PyCoT - Python Cursor-on-Target Toolkit
[](https://www.python.org/downloads/)
[](https://opensource.org/licenses/MIT)
[](https://badge.fury.io/py/pycot)
**PyCoT** is a comprehensive and optimized Python library for working with **Cursor on Target (CoT)** data, the standard used in military and security applications such as ATAK (Android Team Awareness Kit) and WinTAK.
## 🚀 Key Features
- **⚡ Optimized Performance**: Ultra-fast XML parsing with `lxml`
- **🔒 Robust Validation**: Pydantic models for data validation
- **🔄 Multiple Formats**: Conversion to GeoJSON, Cesium, KML, WKT and more
- **🌐 Async Network Transport**: Support for UDP, TCP, TLS and WebSocket
- **📊 Batch Processing**: Efficient handling of multiple events
- **🛠️ CLI Tools**: Integrated command-line utilities
- **📝 Comprehensive Logging**: Configurable logging system
- **🧪 Testing**: Complete unit test coverage
## 📦 Installation
### Basic Installation
```bash
pip install pycot
```
### Installation with Optional Dependencies
```bash
# For better performance
pip install "pycot[speed]"
# For WebSocket support
pip install "pycot[ws]"
# For TAK Protocol support
pip install "pycot[proto]"
# For development
pip install "pycot[dev]"
# For documentation
pip install "pycot[docs]"
```
### Installation from Source
```bash
git clone https://github.com/yourusername/pycot.git
cd pycot
pip install -e .
```
## 🎯 Quick Start
### Basic Conversion
```python
from pycot import CoT
# Create from XML
xml_data = '''
<event uid="demo-1" type="a-f-G-U-C">
<point lat="40.4" lon="-3.7" hae="100"/>
<detail>
<contact callsign="ALPHA-1"/>
<track course="45" speed="25"/>
</detail>
</event>
'''
cot = CoT.from_xml(xml_data)
# Convert to different formats
geojson = cot.to_geojson()
cesium = cot.to_cesium()
kml = cot.to_kml()
wkt = cot.to_wkt()
json_data = cot.to_json()
print(f"Event: {cot}")
print(f"Position: {cot.get_position()}")
print(f"Accuracy: {cot.get_accuracy()}")
```
### Batch Processing
```python
from pycot import CoTCollection, parse_file
# Read multiple events from file
events = parse_file("events.xml")
collection = CoTCollection(events)
# Convert to GeoJSON FeatureCollection
geojson_collection = collection.to_geojson_collection()
# Convert to complete Cesium scene
cesium_scene = collection.to_cesium_scene()
# Export HTML viewer
collection.export_html_viewer("viewer.html")
```
### Network Transport
```python
import asyncio
from pycot import stream_events, send_event
async def receive_events():
"""Receive events from UDP server"""
async for event in stream_events("udp://localhost:8087"):
print(f"Event received: {event.uid}")
# Process event...
async def send_events():
"""Send event to server"""
event_data = '''
<event uid="test-1" type="a-f-G-U-C">
<point lat="40.4" lon="-3.7"/>
</event>
'''
await send_event("tcp://localhost:8087", event_data)
# Execute
asyncio.run(receive_events())
```
## 📚 Complete API
### Main Class: `CoT`
```python
class CoT:
# Constructors
@classmethod
def from_xml(cls, xml: Union[bytes, str]) -> "CoT"
@classmethod
def from_file(cls, file_path: str) -> "CoT"
@classmethod
def from_dict(cls, data: Dict[str, Any]) -> "CoT"
# Conversions
def to_xml(self, pretty: bool = False) -> bytes
def to_geojson(self) -> Dict[str, Any]
def to_cesium(self, options: Optional[Dict] = None) -> Dict[str, Any]
def to_kml(self) -> str
def to_wkt(self) -> str
def to_json(self, **kwargs) -> str
# Utilities
def get_position(self) -> Dict[str, float]
def get_accuracy(self) -> Dict[str, float]
def update_position(self, lat: float, lon: float, hae: Optional[float] = None)
def add_contact(self, callsign: str, **kwargs)
def add_track(self, course: Optional[float] = None, speed: Optional[float] = None)
def export_all_formats(self, output_dir: str = ".", prefix: str = "") -> Dict[str, str]
```
### Event Collection: `CoTCollection`
```python
class CoTCollection:
def __init__(self, events: Optional[List[CoTEvent]] = None)
def add_event(self, event: CoTEvent)
def to_geojson_collection(self) -> Dict[str, Any]
def to_cesium_collection(self, options: Optional[Dict] = None) -> Dict[str, Any]
def to_cesium_scene(self, options: Optional[Dict] = None) -> Dict[str, Any]
def export_html_viewer(self, output_path: str, options: Optional[Dict] = None) -> str
```
### Parsing Functions
```python
# Individual parsing
parse_event(xml_input: XML) -> CoTEvent
parse_event_dict(xml_input: XML) -> Dict[str, Any]
# Batch parsing
parse_many(xml_stream: Iterable[XML]) -> Iterator[Dict[str, Any]]
parse_file(file_path: str) -> List[CoTEvent]
# Validation
validate_cot_xml(xml_input: XML) -> bool
```
### Geographic Conversions
```python
# Individual conversions
event_to_geojson(evt: Union[Dict, CoTEvent]) -> Dict[str, Any]
event_to_json(evt: Union[Dict, CoTEvent]) -> str
event_to_kml(evt: Union[Dict, CoTEvent]) -> str
event_to_wkt(evt: Union[Dict, CoTEvent]) -> str
# Batch conversions
events_to_geojson_collection(events: List[Union[Dict, CoTEvent]]) -> Dict[str, Any]
# Validation and reverse conversion
validate_geojson(geojson: Dict[str, Any]) -> bool
geojson_to_cot(geojson: Dict[str, Any]) -> Dict[str, Any]
```
### Cesium Conversions
```python
# Individual conversions
to_cesium(event: CoTEvent, options: Optional[Dict] = None) -> Dict[str, Any]
# Batch conversions
to_cesium_collection(events: List[CoTEvent], options: Optional[Dict] = None) -> Dict[str, Any]
to_cesium_scene(events: List[CoTEvent], options: Optional[Dict] = None) -> Dict[str, Any]
# HTML generation
cesium_to_html(cesium_scene: Dict[str, Any], options: Optional[Dict] = None) -> str
```
## 🛠️ CLI Tools
### `pycot-cat`: View Events
```bash
# Show event in readable format
pycot-cat event.xml
# Convert to GeoJSON
pycot-cat event.xml --format geojson
# Convert to Cesium
pycot-cat event.xml --format cesium
# Validate XML
pycot-cat event.xml --validate
```
### `pycot-send`: Send Events
```bash
# Send event to UDP server
pycot-send event.xml udp://localhost:8087
# Send to TCP server with TLS
pycot-send event.xml tls://localhost:8087 --cert client.pem --key client.key
# Send multiple events
pycot-send events/*.xml udp://localhost:8087
```
### `pycot-bridge`: Network Bridge
```bash
# UDP to TCP bridge
pycot-bridge udp://localhost:8087 tcp://localhost:8088
# Bridge with filtering
pycot-bridge udp://localhost:8087 tcp://localhost:8088 --filter "type=a-f-G-U-C"
# Bridge with transformation
pycot-bridge udp://localhost:8087 tcp://localhost:8088 --transform geojson
```
## 🔧 Configuration
### Logging
```python
import logging
# Configure logging
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
# PyCoT specific logging
logging.getLogger('pycot').setLevel(logging.DEBUG)
```
### Cesium Options
```python
# Custom Cesium options
cesium_options = {
"pointSize": 15,
"outlineWidth": 3,
"labelScale": 1.0,
"billboardScale": 1.5,
"modelUrl": "models/aircraft.glb",
"enableLighting": True,
"defaultCameraPosition": [-74.0, 40.0, 1000000.0]
}
cesium_entity = cot.to_cesium(options=cesium_options)
```
## 📖 Advanced Examples
### Create Event Programmatically
```python
from pycot import CoT, CoTEvent, Point, Detail, Contact, Track
# Create event from scratch
event = CoTEvent(
type="a-f-G-U-C",
uid="unit-001",
time="2024-01-01T12:00:00Z",
stale="2024-01-01T12:05:00Z",
how="h-g-i-g-o",
point=Point(lat=40.4, lon=-3.7, hae=100),
detail=Detail(
contact=Contact(callsign="ALPHA-1"),
track=Track(course=45, speed=25)
)
)
cot = CoT(event)
```
### Large File Processing
```python
import asyncio
from pycot import parse_many
async def process_large_file(file_path: str):
"""Process large file efficiently"""
async def read_file_chunks():
with open(file_path, 'rb') as f:
chunk = ""
for line in f:
chunk += line.decode('utf-8')
if line.strip().endswith(b'</event>'):
yield chunk
chunk = ""
# Process in batches
async for event_dict in parse_many(read_file_chunks()):
# Process each event
print(f"Processing: {event_dict['uid']}")
# Execute
asyncio.run(process_large_file("large_events.xml"))
```
### External System Integration
```python
from pycot import CoT, CoTCollection
import requests
def fetch_and_process_cot_data(api_url: str):
"""Fetch and process CoT data from external API"""
# Get data
response = requests.get(api_url)
cot_xml_list = response.text.split('</event>')
# Process events
collection = CoTCollection()
for xml_chunk in cot_xml_list:
if xml_chunk.strip():
try:
cot = CoT.from_xml(xml_chunk + '</event>')
collection.add_event(cot.to_event())
except Exception as e:
print(f"Error processing event: {e}")
# Export results
collection.export_html_viewer("external_data_viewer.html")
return collection
```
## 🧪 Testing
```bash
# Run all tests
pytest
# Tests with coverage
pytest --cov=pycot --cov-report=html
# Specific tests
pytest tests/test_parser.py
pytest tests/test_geo.py -v
# Integration tests
pytest -m integration
# Performance tests
pytest -m slow
```
## 📊 Benchmarks
PyCoT is optimized for performance:
- **XML Parsing**: 10x faster than xml.etree
- **GeoJSON Conversion**: 5x faster than standard implementations
- **Memory**: 30% less memory usage
- **Validation**: Real-time validation without performance impact
## 🤝 Contributing
Contributions are welcome! Please:
1. Fork the repository
2. Create a feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request
### Local Development
```bash
git clone https://github.com/yourusername/pycot.git
cd pycot
pip install -e ".[dev]"
# Format code
black src/
isort src/
# Type checking
mypy src/
# Run linting
ruff check src/
```
## 📄 License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
## 🙏 Acknowledgments
- **TAK Product Center** for the CoT standard
- **Cesium** for the 3D visualization platform
- **Pydantic** for the data validation system
- **lxml** for high-performance XML parsing
## 📞 Support
- **Documentation**: [https://pycot.readthedocs.io](https://pycot.readthedocs.io)
- **Issues**: [https://github.com/yourusername/pycot/issues](https://github.com/yourusername/pycot/issues)
- **Discussions**: [https://github.com/yourusername/pycot/discussions](https://github.com/yourusername/pycot/discussions)
---
**PyCoT** - Transforming CoT data into actionable information 🎯
Raw data
{
"_id": null,
"home_page": null,
"name": "PyCoT-tak",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.9",
"maintainer_email": null,
"keywords": "TAK, ATAK, CoT, Cursor on Target, GIS, GeoJSON, Cesium, XML, Parsing, Data Conversion",
"author": "COASsoft",
"author_email": "Oscar Aguilar Ramos <aguilardeciudad@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/63/14/5eb3cf250c0720de621e37699e90825dde1e9ba2faa8357f0a6e03787590/pycot_tak-0.0.4.tar.gz",
"platform": null,
"description": "# PyCoT - Python Cursor-on-Target Toolkit\n\n[](https://www.python.org/downloads/)\n[](https://opensource.org/licenses/MIT)\n[](https://badge.fury.io/py/pycot)\n\n**PyCoT** is a comprehensive and optimized Python library for working with **Cursor on Target (CoT)** data, the standard used in military and security applications such as ATAK (Android Team Awareness Kit) and WinTAK.\n\n## \ud83d\ude80 Key Features\n\n- **\u26a1 Optimized Performance**: Ultra-fast XML parsing with `lxml`\n- **\ud83d\udd12 Robust Validation**: Pydantic models for data validation\n- **\ud83d\udd04 Multiple Formats**: Conversion to GeoJSON, Cesium, KML, WKT and more\n- **\ud83c\udf10 Async Network Transport**: Support for UDP, TCP, TLS and WebSocket\n- **\ud83d\udcca Batch Processing**: Efficient handling of multiple events\n- **\ud83d\udee0\ufe0f CLI Tools**: Integrated command-line utilities\n- **\ud83d\udcdd Comprehensive Logging**: Configurable logging system\n- **\ud83e\uddea Testing**: Complete unit test coverage\n\n## \ud83d\udce6 Installation\n\n### Basic Installation\n\n```bash\npip install pycot\n```\n\n### Installation with Optional Dependencies\n\n```bash\n# For better performance\npip install \"pycot[speed]\"\n\n# For WebSocket support\npip install \"pycot[ws]\"\n\n# For TAK Protocol support\npip install \"pycot[proto]\"\n\n# For development\npip install \"pycot[dev]\"\n\n# For documentation\npip install \"pycot[docs]\"\n```\n\n### Installation from Source\n\n```bash\ngit clone https://github.com/yourusername/pycot.git\ncd pycot\npip install -e .\n```\n\n## \ud83c\udfaf Quick Start\n\n### Basic Conversion\n\n```python\nfrom pycot import CoT\n\n# Create from XML\nxml_data = '''\n<event uid=\"demo-1\" type=\"a-f-G-U-C\">\n <point lat=\"40.4\" lon=\"-3.7\" hae=\"100\"/>\n <detail>\n <contact callsign=\"ALPHA-1\"/>\n <track course=\"45\" speed=\"25\"/>\n </detail>\n</event>\n'''\n\ncot = CoT.from_xml(xml_data)\n\n# Convert to different formats\ngeojson = cot.to_geojson()\ncesium = cot.to_cesium()\nkml = cot.to_kml()\nwkt = cot.to_wkt()\njson_data = cot.to_json()\n\nprint(f\"Event: {cot}\")\nprint(f\"Position: {cot.get_position()}\")\nprint(f\"Accuracy: {cot.get_accuracy()}\")\n```\n\n### Batch Processing\n\n```python\nfrom pycot import CoTCollection, parse_file\n\n# Read multiple events from file\nevents = parse_file(\"events.xml\")\ncollection = CoTCollection(events)\n\n# Convert to GeoJSON FeatureCollection\ngeojson_collection = collection.to_geojson_collection()\n\n# Convert to complete Cesium scene\ncesium_scene = collection.to_cesium_scene()\n\n# Export HTML viewer\ncollection.export_html_viewer(\"viewer.html\")\n```\n\n### Network Transport\n\n```python\nimport asyncio\nfrom pycot import stream_events, send_event\n\nasync def receive_events():\n \"\"\"Receive events from UDP server\"\"\"\n async for event in stream_events(\"udp://localhost:8087\"):\n print(f\"Event received: {event.uid}\")\n # Process event...\n\nasync def send_events():\n \"\"\"Send event to server\"\"\"\n event_data = '''\n <event uid=\"test-1\" type=\"a-f-G-U-C\">\n <point lat=\"40.4\" lon=\"-3.7\"/>\n </event>\n '''\n await send_event(\"tcp://localhost:8087\", event_data)\n\n# Execute\nasyncio.run(receive_events())\n```\n\n## \ud83d\udcda Complete API\n\n### Main Class: `CoT`\n\n```python\nclass CoT:\n # Constructors\n @classmethod\n def from_xml(cls, xml: Union[bytes, str]) -> \"CoT\"\n @classmethod\n def from_file(cls, file_path: str) -> \"CoT\"\n @classmethod\n def from_dict(cls, data: Dict[str, Any]) -> \"CoT\"\n\n # Conversions\n def to_xml(self, pretty: bool = False) -> bytes\n def to_geojson(self) -> Dict[str, Any]\n def to_cesium(self, options: Optional[Dict] = None) -> Dict[str, Any]\n def to_kml(self) -> str\n def to_wkt(self) -> str\n def to_json(self, **kwargs) -> str\n\n # Utilities\n def get_position(self) -> Dict[str, float]\n def get_accuracy(self) -> Dict[str, float]\n def update_position(self, lat: float, lon: float, hae: Optional[float] = None)\n def add_contact(self, callsign: str, **kwargs)\n def add_track(self, course: Optional[float] = None, speed: Optional[float] = None)\n def export_all_formats(self, output_dir: str = \".\", prefix: str = \"\") -> Dict[str, str]\n```\n\n### Event Collection: `CoTCollection`\n\n```python\nclass CoTCollection:\n def __init__(self, events: Optional[List[CoTEvent]] = None)\n def add_event(self, event: CoTEvent)\n def to_geojson_collection(self) -> Dict[str, Any]\n def to_cesium_collection(self, options: Optional[Dict] = None) -> Dict[str, Any]\n def to_cesium_scene(self, options: Optional[Dict] = None) -> Dict[str, Any]\n def export_html_viewer(self, output_path: str, options: Optional[Dict] = None) -> str\n```\n\n### Parsing Functions\n\n```python\n# Individual parsing\nparse_event(xml_input: XML) -> CoTEvent\nparse_event_dict(xml_input: XML) -> Dict[str, Any]\n\n# Batch parsing\nparse_many(xml_stream: Iterable[XML]) -> Iterator[Dict[str, Any]]\nparse_file(file_path: str) -> List[CoTEvent]\n\n# Validation\nvalidate_cot_xml(xml_input: XML) -> bool\n```\n\n### Geographic Conversions\n\n```python\n# Individual conversions\nevent_to_geojson(evt: Union[Dict, CoTEvent]) -> Dict[str, Any]\nevent_to_json(evt: Union[Dict, CoTEvent]) -> str\nevent_to_kml(evt: Union[Dict, CoTEvent]) -> str\nevent_to_wkt(evt: Union[Dict, CoTEvent]) -> str\n\n# Batch conversions\nevents_to_geojson_collection(events: List[Union[Dict, CoTEvent]]) -> Dict[str, Any]\n\n# Validation and reverse conversion\nvalidate_geojson(geojson: Dict[str, Any]) -> bool\ngeojson_to_cot(geojson: Dict[str, Any]) -> Dict[str, Any]\n```\n\n### Cesium Conversions\n\n```python\n# Individual conversions\nto_cesium(event: CoTEvent, options: Optional[Dict] = None) -> Dict[str, Any]\n\n# Batch conversions\nto_cesium_collection(events: List[CoTEvent], options: Optional[Dict] = None) -> Dict[str, Any]\nto_cesium_scene(events: List[CoTEvent], options: Optional[Dict] = None) -> Dict[str, Any]\n\n# HTML generation\ncesium_to_html(cesium_scene: Dict[str, Any], options: Optional[Dict] = None) -> str\n```\n\n## \ud83d\udee0\ufe0f CLI Tools\n\n### `pycot-cat`: View Events\n\n```bash\n# Show event in readable format\npycot-cat event.xml\n\n# Convert to GeoJSON\npycot-cat event.xml --format geojson\n\n# Convert to Cesium\npycot-cat event.xml --format cesium\n\n# Validate XML\npycot-cat event.xml --validate\n```\n\n### `pycot-send`: Send Events\n\n```bash\n# Send event to UDP server\npycot-send event.xml udp://localhost:8087\n\n# Send to TCP server with TLS\npycot-send event.xml tls://localhost:8087 --cert client.pem --key client.key\n\n# Send multiple events\npycot-send events/*.xml udp://localhost:8087\n```\n\n### `pycot-bridge`: Network Bridge\n\n```bash\n# UDP to TCP bridge\npycot-bridge udp://localhost:8087 tcp://localhost:8088\n\n# Bridge with filtering\npycot-bridge udp://localhost:8087 tcp://localhost:8088 --filter \"type=a-f-G-U-C\"\n\n# Bridge with transformation\npycot-bridge udp://localhost:8087 tcp://localhost:8088 --transform geojson\n```\n\n## \ud83d\udd27 Configuration\n\n### Logging\n\n```python\nimport logging\n\n# Configure logging\nlogging.basicConfig(\n level=logging.INFO,\n format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'\n)\n\n# PyCoT specific logging\nlogging.getLogger('pycot').setLevel(logging.DEBUG)\n```\n\n### Cesium Options\n\n```python\n# Custom Cesium options\ncesium_options = {\n \"pointSize\": 15,\n \"outlineWidth\": 3,\n \"labelScale\": 1.0,\n \"billboardScale\": 1.5,\n \"modelUrl\": \"models/aircraft.glb\",\n \"enableLighting\": True,\n \"defaultCameraPosition\": [-74.0, 40.0, 1000000.0]\n}\n\ncesium_entity = cot.to_cesium(options=cesium_options)\n```\n\n## \ud83d\udcd6 Advanced Examples\n\n### Create Event Programmatically\n\n```python\nfrom pycot import CoT, CoTEvent, Point, Detail, Contact, Track\n\n# Create event from scratch\nevent = CoTEvent(\n type=\"a-f-G-U-C\",\n uid=\"unit-001\",\n time=\"2024-01-01T12:00:00Z\",\n stale=\"2024-01-01T12:05:00Z\",\n how=\"h-g-i-g-o\",\n point=Point(lat=40.4, lon=-3.7, hae=100),\n detail=Detail(\n contact=Contact(callsign=\"ALPHA-1\"),\n track=Track(course=45, speed=25)\n )\n)\n\ncot = CoT(event)\n```\n\n### Large File Processing\n\n```python\nimport asyncio\nfrom pycot import parse_many\n\nasync def process_large_file(file_path: str):\n \"\"\"Process large file efficiently\"\"\"\n\n async def read_file_chunks():\n with open(file_path, 'rb') as f:\n chunk = \"\"\n for line in f:\n chunk += line.decode('utf-8')\n if line.strip().endswith(b'</event>'):\n yield chunk\n chunk = \"\"\n\n # Process in batches\n async for event_dict in parse_many(read_file_chunks()):\n # Process each event\n print(f\"Processing: {event_dict['uid']}\")\n\n# Execute\nasyncio.run(process_large_file(\"large_events.xml\"))\n```\n\n### External System Integration\n\n```python\nfrom pycot import CoT, CoTCollection\nimport requests\n\ndef fetch_and_process_cot_data(api_url: str):\n \"\"\"Fetch and process CoT data from external API\"\"\"\n\n # Get data\n response = requests.get(api_url)\n cot_xml_list = response.text.split('</event>')\n\n # Process events\n collection = CoTCollection()\n for xml_chunk in cot_xml_list:\n if xml_chunk.strip():\n try:\n cot = CoT.from_xml(xml_chunk + '</event>')\n collection.add_event(cot.to_event())\n except Exception as e:\n print(f\"Error processing event: {e}\")\n\n # Export results\n collection.export_html_viewer(\"external_data_viewer.html\")\n return collection\n```\n\n## \ud83e\uddea Testing\n\n```bash\n# Run all tests\npytest\n\n# Tests with coverage\npytest --cov=pycot --cov-report=html\n\n# Specific tests\npytest tests/test_parser.py\npytest tests/test_geo.py -v\n\n# Integration tests\npytest -m integration\n\n# Performance tests\npytest -m slow\n```\n\n## \ud83d\udcca Benchmarks\n\nPyCoT is optimized for performance:\n\n- **XML Parsing**: 10x faster than xml.etree\n- **GeoJSON Conversion**: 5x faster than standard implementations\n- **Memory**: 30% less memory usage\n- **Validation**: Real-time validation without performance impact\n\n## \ud83e\udd1d Contributing\n\nContributions are welcome! Please:\n\n1. Fork the repository\n2. Create a feature branch (`git checkout -b feature/amazing-feature`)\n3. Commit your changes (`git commit -m 'Add amazing feature'`)\n4. Push to the branch (`git push origin feature/amazing-feature`)\n5. Open a Pull Request\n\n### Local Development\n\n```bash\ngit clone https://github.com/yourusername/pycot.git\ncd pycot\npip install -e \".[dev]\"\n\n# Format code\nblack src/\nisort src/\n\n# Type checking\nmypy src/\n\n# Run linting\nruff check src/\n```\n\n## \ud83d\udcc4 License\n\nThis project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.\n\n## \ud83d\ude4f Acknowledgments\n\n- **TAK Product Center** for the CoT standard\n- **Cesium** for the 3D visualization platform\n- **Pydantic** for the data validation system\n- **lxml** for high-performance XML parsing\n\n## \ud83d\udcde Support\n\n- **Documentation**: [https://pycot.readthedocs.io](https://pycot.readthedocs.io)\n- **Issues**: [https://github.com/yourusername/pycot/issues](https://github.com/yourusername/pycot/issues)\n- **Discussions**: [https://github.com/yourusername/pycot/discussions](https://github.com/yourusername/pycot/discussions)\n\n---\n\n**PyCoT** - Transforming CoT data into actionable information \ud83c\udfaf\n",
"bugtrack_url": null,
"license": null,
"summary": "PyCoT: Python Cursor-on-Target toolkit (node-CoT style) with XML->CoTEvent, GeoJSON, Cesium conversion capabilities",
"version": "0.0.4",
"project_urls": {
"Documentation": "https://github.com/COASsoft/PyCoT",
"Homepage": "https://github.com/COASsoft/PyCoT",
"Issues": "https://github.com/COASsoft/PyCoT/issues",
"Repository": "https://github.com/COASsoft/PyCoT"
},
"split_keywords": [
"tak",
" atak",
" cot",
" cursor on target",
" gis",
" geojson",
" cesium",
" xml",
" parsing",
" data conversion"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "701dc1980344105e81a803413546d35a17c2170ce934accff3eccf07ec79a9ba",
"md5": "1b5334723a090d1b48bf48ec5b565360",
"sha256": "51c2ee66b79f365fbaa7767c3949237e94ed2321215e79103d1a8de1b6c86d90"
},
"downloads": -1,
"filename": "pycot_tak-0.0.4-py3-none-any.whl",
"has_sig": false,
"md5_digest": "1b5334723a090d1b48bf48ec5b565360",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.9",
"size": 25563,
"upload_time": "2025-08-18T13:00:37",
"upload_time_iso_8601": "2025-08-18T13:00:37.806006Z",
"url": "https://files.pythonhosted.org/packages/70/1d/c1980344105e81a803413546d35a17c2170ce934accff3eccf07ec79a9ba/pycot_tak-0.0.4-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "63145eb3cf250c0720de621e37699e90825dde1e9ba2faa8357f0a6e03787590",
"md5": "1f977f0fcc11c8887cea3f8dc183f8d1",
"sha256": "a59bf3959802ed38912c2b529ca7830a64d7e7ac33e7f9f053f8ccf53d45c511"
},
"downloads": -1,
"filename": "pycot_tak-0.0.4.tar.gz",
"has_sig": false,
"md5_digest": "1f977f0fcc11c8887cea3f8dc183f8d1",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.9",
"size": 23427,
"upload_time": "2025-08-18T13:00:39",
"upload_time_iso_8601": "2025-08-18T13:00:39.225277Z",
"url": "https://files.pythonhosted.org/packages/63/14/5eb3cf250c0720de621e37699e90825dde1e9ba2faa8357f0a6e03787590/pycot_tak-0.0.4.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-08-18 13:00:39",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "COASsoft",
"github_project": "PyCoT",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"lcname": "pycot-tak"
}
JSON
