Release/2.0 dev

[robberwick]

This PR introduces several key changes aimed at modernizing and improving the BlinkStick Python library:

• Refactoring: Significant restructuring of the codebase to enhance readability and maintainability. Legacy patterns have been replaced with more efficient and modern Python constructs.

• Type Hinting: The inclusion of type annotations provides better integration with IDEs and static analysis tools, improving developer experience and reducing runtime errors.

• Unit Tests: Unit tests have been added to improve the code's reliability and ensure coverage for new and existing features.

• Project Configuration: The build system now conforms to PEP 517/518 standards by adopting pyproject.toml, replacing older methods for defining project dependencies and metadata.

• GitHub Actions Integration: Continuous Integration (CI) workflows have been implemented using GitHub Actions to automate testing, linting, and builds, ensuring consistent code quality and streamlined development.

These updates collectively enhance the library's usability, adherence to modern Python standards, and developer experience.

Refactoring

The refactoring changes introduced in the release/2.0-dev branch of the BlinkStick Python library represent a significant overhaul of the codebase. These changes aim to enhance code quality, performance, and maintainability. Key refactoring updates include:

1. Code Structure and Readability Improved organization of classes and functions into smaller, logical units that align with the single-responsibility principle. Simplification of complex or redundant logic, making the code easier to understand and debug. Removal of legacy constructs and obsolete code, replacing them with Pythonic idioms.
2. Adoption of Modern Python Features Utilization of f-strings for more readable and efficient string formatting. Introduction of list comprehensions and generator expressions in place of verbose loops for concise and efficient data processing. Use of context managers (e.g., with statements) to handle resources like files or devices, ensuring proper cleanup.
3. Enhanced Error Handling Refined exception handling mechanisms to provide more informative error messages and avoid silent failures. Centralization of error management logic for consistent behavior across the library.
4. Encapsulation and Abstraction Refactoring of private and internal methods to ensure proper encapsulation and reduce interdependencies. Consolidation of reusable logic into helper functions or utility modules.
5. Improved Maintainability Consistent application of PEP 8 standards across the codebase. Addition of docstrings and inline comments to enhance code documentation and ease onboarding for new contributors.

Backend Implementations:

• Added UnixLikeBackend class in src/blinkstick/backends/unix_like.py to handle BlinkStick devices on Unix-like systems.
• Added Win32Backend class in src/blinkstick/backends/win32.py to handle BlinkStick devices on Windows systems.

Type Hinting

type hinting has been introduced as a key modernization effort. This update enhances code clarity, facilitates developer productivity, and supports better integration with modern development tools.

Benefits and Implementation of Type Hinting

• Improved Code Readability:

  Function signatures now explicitly indicate the expected types for parameters and return values. For example:

  def set_color(self, index: int, color: str) -> bool:

  This makes the codebase self-documenting, reducing the need for extensive comments or external documentation.

• Enhanced Development Tools Support:

  Type hinting integrates seamlessly with IDEs like PyCharm and VS Code, enabling features such as auto-completion, inline documentation, and static type analysis. Tools like mypy can now be used to perform static type checks, identifying potential bugs before runtime.

• Error Reduction:

  Explicit type definitions help prevent errors caused by incorrect data types being passed to functions, improving overall robustness.

• Compatibility with Modern Python:

  By using Python’s typing module, the library aligns with best practices in modern Python development. This includes the use of advanced typing constructs such as Optional, Union, and List.

• Foundation for Future Enhancements:

  The consistent use of type hints makes the library easier to extend and maintain, especially for new contributors or developers less familiar with the project.

Examples of Type Hinting Introduced

• Basic Type Annotations:

  def blink(self, duration: float) -> None:

• Complex Types:

  def get_device_info(self) -> Optional[Dict[str, Any]]:

Broader Impact

Type hinting not only brings immediate benefits to the BlinkStick project but also positions it as a modern and developer-friendly library in the Python ecosystem. It reduces friction for both current maintainers and new contributors.

Unit Tests

• Unit tests added, targeting critical parts of the library, including device initialization, data transmission, and mode settings.
• Tests cover edge cases, ensuring robust error handling and correct functionality under unexpected conditions.

Project Configuration:

• Updated pyproject.toml to include build system requirements, project metadata, dependencies, optional dependencies, and tool configurations for Black and isort.
• Removed setup.py and replaced it with pyproject.toml for project configuration and dependency management.
• Removed MANIFEST and MANIFEST.in files as they are no longer needed with the new project configuration. [1] [2]

GitHub Actions Integration:

• Added a black.yml workflow to check code formatting using Black on push and pull request events.
• Added a mypy.yml workflow to perform type checking using Mypy on push and pull request events.
• Added a pytest.yml workflow to run tests on multiple operating systems and Python versions for pull requests targeting specific branches.

Misc Updates:

• Updated src/blinkstick/__init__.py to use importlib.metadata for package version retrieval and restructured imports.
• Added a new example script examples/random_color.py to demonstrate BlinkStick usage and exception handling.

These changes introduce platform-specific backend implementations for better device handling, improve project configuration management, and enhance the project's CI/CD pipeline, , and .