Explore Projects

LPython is still in its pre-alpha stage of development. When it becomes functional, LPython aims to be an ahead-of-time (AOT) compiler for Python that can compile binaries and execute code interactively at blazing fast speed. At present, the frontend of the LPython compiler is very limited (and slow too). My project aims to improve the frontend by developing the tokenizer and the parser from scratch. For the tokenizer, we will be using re2c and GNU Bison for the parser generator.

Generics are a common functionality found in statically typed programming languages, allowing easier maintenance of programs which differ only in their types. However, generics are not yet supported in the statically-typed LPython. Generics in LPython can be implemented similar to the approach taken by C++ templates. We can regard generic functions as functions with type parameters, whose parameters are made concrete and checked by function calls on AST level. The end result of the project would be generic function support for LPython with option for specialization, along with sufficient integration tests and documentations.

This project aims to improve the code coverage of the project. Getting the test coverage to over 95%, which is currently hovering around 80% coverage according to codecov. Using fuzzers on some file inputs in SBOM module and Report code to find new bugs and fix them. Optimizing code and adding tests to increase the general robustness of the code. This will be helpful for the tool in getting bug-free efficient code.

<p><strong>Neural source reconstruction</strong> of MEG/EEG data requires subject specific geometrical data (i.e. electrode locations and anatomical brain data). For many reconstruction techniques, results are volumetric rather than surface-based. A group level analysis for volumetric data has not yet been implemented in MNE Python. The proposed project aims to fill this gap, by implementing necessary tools for group level analyses based on <strong>volumetric data</strong>, among which are: non-linear warping of one volumetric (grid) space to another; creating pseudo-individual anatomical MR images, based on a subject’s head shape; and output preparation, such that it can be used with already built in statistical functions. The results will be a set of Python functions that enable the user to prepare individual volumetric subject data for <strong>group level analyses</strong>. Furthermore the respective visualization will be targeted as well.</p>

Modernize fs_filepicker: The fs_filepicker is a GUI used for selecting files in the msui_settings.json configuration file. Currently, the GUI only offers a basic set of navigation elements for selecting a file and returns the fs URL for accessing it. The goal of this project is to modernize the GUI using the Pyfilesystem module to make it more user-friendly and efficient. Pyfilesystem is a Python module used for accessing different types of file systems. It provides a common API for working with various file systems, such as local, remote, and cloud-based storage systems. The Pyfilesystem module is easy to use and has many features that can be used to improve the functionality of the fs_filepicker. View Layout and Restoring:: The mscolab project is a collaborative software platform that enables multiple users to work together on a shared project in real-time. The project is written in Python and uses the PyQT GUI library for the user interface. Currently, the PyQT Gui of the MSS client can handle different views by one flight path. However, once a new flight path is loaded and activated, all views change to this flight path. This is inconvenient for users who want to work on multiple flight paths simultaneously. Additionally, the view configuration consists of many windows with a complex set of configuration options that are tedious to re-create after shutting down the application. This proposal aims to improve the mscolab user interface by adding the ability to store and restore the view configuration of multiple windows for the user. Additionally, the proposal seeks to add a layout option for any participant on the same flight path, as well as the ability for the creator of an operation to set the layout of all participants.

<ul> <li>Merging of MSUI and MSColab windows for a more intuitive workflow, since both the windows share some core functionalities. My proposal includes,<ul> <li>Redesigning and Implementation of the new UI</li> <li>Migrating MSColab features to the new window</li> <li>Refactoring core-logic</li> <li>New profile page for the users</li> </ul> </li> <li>Design and implementation of new configuration editor. Since MSS uses json files for storing configurations, it requires the user to have a prior knowledge about the json syntax. With the proposed configuration editor the user can solely focus on modifying, adding, deleting configurations.</li> </ul>

<p>The main goal of this project is to make the APIs more reliable, faster, operational and easy to maintain.</p> <p>Firstly, I will work on determining the aspects that need to be improved or refactored in the current codebase, and then introducing more domain-features like Generating SVG code-snippets, base64 encoded image, tags recommendation and adding the possibility of searching with different languages.</p> <p>Eos-icons is a search-heavy project, which necessitates having a great search process starting from the search-input in the frontend and ending in getting your desired icons in seconds! for this to be achieved, a search-engine layer will be added to manage the process of searching/filtering, also the icons will be added to a MongoDB instance, with a caching layer in front of it, to have a much faster responses.</p> <p>Lastly, I will be working on adding unit tests, to make sure that the APIs work as expected, alongside with creating a Docker Image, to have a solid deployment solution.</p>

Blender supports video editing through its video sequence editor. While the editor allows users to load videos and audio files, computing the audio waveforms for the audio tracks can take a really long time when working with large files (multiple gigabytes). This makes for a degraded user experience. This project will reduce the time taken to see the waveforms by: ● Processing multiple audio sequences in parallel in the background, ● Only computing the waveforms of sequences that are visible in the user interface Once these initial speed ups are achieved, I'll explore improvement opportunities lower down the audio processing stack.

The project aims to modernize and enhance the functionality and performance of DIPY (Diffusion Imaging in Python), a library for the analysis of diffusion magnetic resonance imaging (dMRI) data. The focus is on making key improvements across several areas to ensure the tool remains a cutting-edge resource for scientific visualization within the Python community. Here's a concise overview: Problem Addressed: The project addresses the need for improved code robustness, performance optimization, and user experience in DIPY. Specific challenges include the current lack of keyword-only arguments in functions, inefficient resource loading, bulky website management, and the need for better documentation and learning resources. Deliverable with approach: 1. Keyword-Only Arguments: Audit and refactor functions to use keyword-only arguments for clearer, more robust code. 2. Lazy Loading: Implement lazy loading to optimize performance by loading resources on-demand. 3. Website Management Improvement: Work with mentors to identify and implement enhancements for easier website management. 4. GitHub Actions Integration: Automate development workflows with GitHub Actions to improve efficiency and reduce errors. 5. Issues and Pull Requests Triage Automation: Enhance and automate the triage process for better project management. 6. Refactoring and Documentation: Refactor DIPY packages for improved readability and maintainability, and enhance docstrings for better documentation. 7. Tutorials Addition: Create new tutorials based on community feedback and identified learning gaps to facilitate user adoption and learning.

This project aims to expand support for serious games within the Cormas platform, enabling easier interaction between players and environment, and autonomous agents. By extending Cormas with “playable” components the project will contribute to the development of a generic solution for designing, playing, and analyzing serious games. The planned development includes three phases, covering initial implementation, testing, and system optimization, with the ultimate goal of creating a first working prototype with a user interface accessible via a smartphone.

<p>OpenLex is a legal management system developed in web2py this system has the advantage that it can be run on any operating system thanks to the fact that it is a web browser application, however, for this reason it represents mistrust among users due to ignorance about the security and system integrity because this is used by a browser and not as a desktop application. In order to satisfy these users, the development of the installer in the different versions of linux, windows and apple is proposed in the project issues.</p>

<p>This will be a continuation of the previous summer’s <strong>Outliner Improvements</strong> project. With selection now syncing between the outliner and other editors, other improvements can be made to the outliner to increase usability. These include changes to the context menu, a connection with the properties editor tabs, manual object sorting, and increased control over selection and activation of data types.</p>

Implement a Keyframe animation system for FURY with public API that has the following functionalities: Play, pause, rewind, and reverse play the timeline. Add or remove keyframes at any specific time. Interpolate position, scale, rotation (using SLERP), and opacity for the animated actors or camera using linear and non-linear methods. Visualize the motion path of the translation.

<p>Scrapy presently only supports HTTP/1.x to issue network requests. This project aims to implement HTTP/2 support adding an HTTP handler that can gracefully upgrade to HTTP/2 where possible, and take advantage of the compression and efficient gains.</p>

<p>The CVE Binary Tool scans for a set of checkers, which are common, vulnerable open source components and lets us know if a given directory or binary file includes common libraries with known vulnerabilities. The tool, at its launch, had checkers for 10 different open source libraries. But since there are a lot of common open source libraries with vulnerabilities, we want to incorporate the CVE Binary Tool with as many checkers as possible.</p>

<p>Developing of the pipeline for crystallography analysis including GUI development</p>

<p>I intend to work on the scrapy benchmarking suite project. I would like to create benchmarks that reflect real-life cases as well as component-specific micro benchmarks.<code>--profile</code> uses cProfile for profiling and the feature is currently undocumented. I intend to investigate other profilers to be used with scrapy and try to improve the performance of the spiders based on the results.</p>

<p>In mercurial, there are some write commands which have a --dry-run flag that turns on a mode in which user will get to know what will be the result output, without actually running that command. The focus of this project is to add dry-run functionality to each write command which are good candidate at present. Some good candidates are phase, strip, pull, push, amend, graft, merge, rebase, histedit and unshelve. In case of rebase, histedit and graft prints out the graph that would result if we ran the command.</p>

Modernization of the FURY code base to improve readability, maintainability and performance. This project aims to modernize the FURY code base by implementing keyword-only arguments to improve code clarity and explicit parameter passing. In addition, the integration of lazy loading functionality will optimize performance by loading resources only when they are needed. Finally, active participation in code refactoring efforts will improve the structure and maintainability of the FURY code base. The project will result in a modernized code base, comprehensive unit testing, updated Sphinx documentation and public presentations illustrating the improvements and benefits. Ultimately, the aim is to significantly improve the FURY code base for future developers and users.

This project aims to add enhancements, solve issues and improve the user interface of the Python Software Foundation GSoC Blog platform. Currently, there are several issues listed on the issue tracker of the PSF GSoC Blog. This project aims to solve those issues and improve the usability of the blog platform for admins and students.

<p>Library of Time Series Methods aims to implement various time series methods for astronomical X-ray data. A lot of data is being collected by X-ray satellites set up by astronomers that is in form of time series. Time series analysis of this data is extensively done by astronomical researchers to reach at useful discoveries. Unfortunately, there is no dedicated tool that provide reliable and tested time series analysis methods for astronomical data. Stingray is an effort by open-source community that aims to provide a python package for time series analysis of X-ray data that hopefully would be a go-to package for astronomical community to carry out their research on time series data.</p>

lpython is a statically typed compiled programming language with syntax inspired by Python programming language. lpython also aims to have first-class support to work with Python and C libraries. lpython has multiple backend targets like C, C++, and LLVM IR that can be compiled to target executables with appropriate C/C++ compiler or the LLVM compiler toolchain. As lpython is statically typed and ahead-of-time compiled it offers much better performance than cpython. The current state of lpython is not feature-complete nor bug-free. I propose to add an interactive shell for lpython, so that the developers can quickly prototype ideas, and improve the debug information generated for the LLVM backend so that users can execute a single line of code at a time and pretty print variables and complex datatypes.

<ul> <li>In mercurial we have various commands like graft, histedit, rebase, shelve, etc. which when used might end up in a conflicted state which then requires the user to intervene and give commands which abort or continue the operation that is currently being executed. There are pre-developed <code>--abort</code> and <code>--continue</code> flags which help the user to do so, however, the downside of this is that the user needs to remember the last command that he used. This project is all about implementing generic <code>hg continue</code> and <code>hg abort</code> commands which will automatically scan for the command that is being currently in conflict. Furthermore, this will provide with the functionality for extensions to plug in their logic to abort and continue the operation.</li> <li>This project will also add the option of <code>hg update --abort</code> which will add the logic to revert back from an update after the merge conflict has already occurred. This is one of the most requested features in mercurial which has not yet been resolved.</li> </ul>