Removed unused imports across various modules, streamlining the codebase by eliminating the `ast` and `tokenize` modules where not directly utilized. This clean-up not only simplifies the code making it more maintainable but also potentially improves runtime performance by reducing overhead. Additionally, redundant variables and comments that do not contribute to clarity or functionality, such as `script_dir` and detailed notes on module path construction, were pruned to further enhance code readability and efficiency.
This change underscores our commitment to maintaining a lean and efficient codebase, facilitating easier updates and modifications in the future.
Removed the duplicate translation mapping for "from" in the Deuthon dictionary, consolidating under "aus" to avoid redundancy and enhance consistency. This change streamlines translation mappings, facilitating easier maintenance and clarity in code translation processes.
Improve the handling of expression evaluation results in the interpreter by attempting to use `__repr__`, falling back to `str`, and finally relying on a basic string conversion if necessary. This approach ensures more robust and informative output for various types of objects, addressing potential issues where the direct conversion to a string might fail or not provide sufficiently detailed information.
This enhancement makes the interpreter more user-friendly and resilient, delivering clearer feedback to users about the outcomes of their operations and making debugging more straightforward.
Introduced changes significantly improve how German code scripts are handled, ensuring a more robust and flexible execution environment. By wrapping the execution of transpiled code in a dedicated module, we facilitate a cleaner namespace management and mimic the natural Python script execution context more closely. This approach also allows for improved error handling and tracebacks that are more meaningful to the end-user.
The addition of "ausgenommen" as an alternative to "except" in the dictionary broadens the tool's understanding of German code, enhancing its flexibility and user-friendliness.
We've refined the module import mechanism to include a wider array of search paths, notably the script's directory and the current working directory, before falling back to the predefined wrappers directory. This enhancement makes the import process more intuitive and aligned with Python's standard behavior, ensuring that dependencies are resolved more reliably across diverse execution environments.
These improvements collectively bolster the tool's usability, making it more accommodating for users running and developing German-translated Python scripts.
Removed redundant imports of `deuthon.base` from `__main__.py`, cleaning up the module's import statements to enhance readability and maintainability. Also, annotated an `except` block with `noqa: F821` to suppress a specific linter warning related to the use of an undefined name. This change clarifies the intentional use of dynamic features and exceptions handling within the codebase, ensuring linting tools can accommodate our dynamic execution context without compromising code quality checks.
This cleanup contributes to a leaner codebase, potentially improving load times and reducing memory footprint, aligning with our ongoing efforts to optimize the performance and clarity of the Deuthon project.
Introduced better error handling in the Deuthon interpreter loop by wrapping the code execution in a try-except block to catch and print exceptions using `traceback`. This change also updates the interpreter to only print output when `eval` returns a non-None result, enhancing usability and feedback for the user. The addition of `traceback` provides users with more insightful error messages, helping to debug incorrect German code inputs more effectively.
Added a new module defining wrapper classes around Python's fundamental data types in the Deuthon programming language style. This setup paves the way for extending standard types with additional Deuthon-specific functionalities and characteristics in the future. It marks a foundational step in making Deuthon a more feature-rich, Python-compatible language.
Removed an unnecessary import of `setuptools` from `__main__.py`. This cleanup reduces the module's dependencies and potentially decreases startup time, making the codebase more efficient and lightweight. No significant functionality is affected by this change, consistent with our ongoing efforts to streamline the code.
Prepares for built-in module overrides by explicitly importing the `json` module within the `prepare_builtin_overrides` function. This approach ensures that any modifications or custom logic applied to the system's version of JSON does not unintentionally conflict with the original module's functionality. The aliasing of the original JSON module under a new name allows for safe manipulation and extension of JSON handling capabilities without affecting the global namespace or existing dependencies that rely on the unmodified JSON module.
This strategic import and module aliasing facilitate future enhancements and potentially complex custom behaviors, ensuring that extensions or modifications are both isolated and reversible, safeguarding the integrity of the application's core functionalities.
Resolved a minor but crucial bug where the `quelladdresse` parameter's default value in the `HTÜPVerbindung` constructor was mistakenly set to `Nicht`. It has been corrected to `Nichts` (None), ensuring consistency with other default parameter values and preventing potential runtime errors related to type mismatches or unexpected behavior in network operations where a source address is not specified. This fix enhances the robustness of HTTP connections established using our custom wrapper, contributing to more reliable network communication in our applications.
Updated the debug message in the test suite to use a more explicit type conversion method when displaying the current file name. This change ensures consistency and clarity in type handling within debug messages. By switching to `zeichenkette(__datei__)` for converting the file name to a string, the code becomes more readable and aligns with best practices for type conversion. This adjustment is particularly relevant for maintaining code quality and could help in future troubleshooting or enhancements by making the debug output more predictable and standardized.
Refactored the HTTP wrapper classes to introduce `HTÜPVerbindung`, a new class that supports configurable timeout, source address, and block size for HTTP connections, enhancing flexibility and control for HTTP requests in the Deuthon project. The `HTÜPAntwort` class now focuses solely on reading the response.
Removed unused imports in dictionary initialization and standardized quote usage for string literals in the transformer module. These changes promote code consistency and reduce clutter, making the codebase cleaner and more maintainable. Additionally, includes minor formatting improvements for readability.
Introduced the Deuthon language interpreter for parsing and executing code written with German-like syntax in Python. Added infrastructure files, including a .gitignore, LICENSE, and pyproject.toml, defining the project setup and metadata. Implemented core modules to handle the language-specific logic, such as token transformations, custom import hooks, and wrappers for standard library modules with German names. This foundation enables the development and testing of Deuthon scripts, laying the groundwork for future enhancements and community contributions.
