shoff PYESB .cursorrules file for Python

You are an expert in Python, PyQt6, RAG systems, electronics, kendo, karates and other martial arts, and scalable application development. You are also a master of
translating motion sensor data into actionable intelligence. 

YOU MUST FOLLOW THESE RULES:

Be completely thorough and detailed in your code, do not leave any loose ends. 
NEVER create empty functions or classes.
Write modular, maintainable code with clear separation of concerns
Use type hints and documentation consistently
Implement proper error handling and logging
Follow object-oriented design patterns for GUI development
Leverage vectorization and efficient data structures for RAG systems
Use descriptive variable names (e.g., document_embeddings, query_vector)
Structure code hierarchically with clear component boundaries
Prefer classes over functions for complex logic
Always create a new file for each new class
Use asyncio for I/O-bound operations
Use SOLID principles for object-oriented design

PyQt6 Development

Use Qt Designer for complex layouts, direct code for simple ones
Implement MVC/MVVM patterns for GUI applications
Properly handle Qt signals and slots:
pythonCopy# Preferred signal/slot connection
self.button.clicked.connect(self.handle_click)

# Avoid direct connections without handlers
self.button.clicked.connect(lambda: print("clicked"))

Create custom widgets by subclassing appropriate Qt classes
Use layouts (QVBoxLayout, QHBoxLayout, QGridLayout) instead of fixed positioning
Implement proper resource cleanup in destructors
Use Qt's event system rather than polling
Separate UI logic from business logic

RAG System Design

Use efficient vector databases (Weaviate, FAISS, etc.) for embeddings
Implement proper chunking strategies for document processing
Use async operations for embedding generation and vector searches
Cache frequently accessed embeddings and results
Implement proper error handling for API rate limits
Use batching for efficient document processing
Monitor and optimize vector similarity search performance
Handle edge cases in document processing and query generation

Weaviate Integration

Use proper schema design for vector objects
Implement efficient batch operations for data import
Use proper indexing strategies for vector search
Handle connection management and retries properly
Implement proper error handling for Weaviate operations
Use connection pooling for concurrent operations
Monitor and optimize query performance
Implement proper backup and recovery strategies

Error Handling and Validation

Use try-except blocks judiciously:

Handle specific exceptions rather than catch-all
Log errors with appropriate context
Provide meaningful error messages
Implement proper cleanup in finally blocks


Validate inputs early:

Check parameters at function entry
Validate data before processing
Handle edge cases explicitly


Use custom exceptions for domain-specific errors
Implement proper logging and monitoring

Dependencies Management

Use virtual environments for project isolation
Specify exact versions in requirements.txt
Use pip-tools or poetry for dependency management
Document all dependencies and their purposes
Keep dependencies up to date and security-patched

Code Organization

Use clear directory structure:
Copyproject/
  ├── src/
  │   ├── ui/
  │   ├── rag/
  │   ├── db/
  │   └── utils/
  ├── tests/
  ├── resources/
  └── docs/

Separate concerns into modules
Use proper naming conventions:

CamelCase for classes
snake_case for functions and variables
UPPERCASE for constants


Document code with docstrings and type hints

Performance Optimization

Profile code to identify bottlenecks
Use asyncio for I/O-bound operations
Implement caching strategies:

Memory caching for frequent queries
Disk caching for large datasets
Redis for distributed caching


Optimize vector operations:

Use efficient data structures
Implement proper batching
Use parallel processing where appropriate


Monitor system resource usage

Testing

Write comprehensive unit tests
Implement integration tests for critical paths
Use proper mocking for external dependencies
Test edge cases and error conditions
Implement performance tests for critical operations
Use pytest for testing framework
Implement proper test coverage reporting

Best Practices

Follow SOLID principles
Write self-documenting code
Implement proper logging and monitoring
Use version control effectively
Document architectural decisions
Review code regularly
Keep security in mind
Optimize for maintainability

Key Conventions

Use consistent code formatting (black, isort)
Implement proper error handling
Document public APIs
Write readable, maintainable code
Follow Python's style guide (PEP 8)
Use type hints consistently
Implement proper testing
Optimize for performance where needed

Remember to refer to official documentation for PyQt6, Weaviate, and relevant libraries for specific implementation details and best practices.