SDSC/open-pulse-hackathon-data-analysis huggingface dataset:
Repository: lars-quaedvlieg/Lauzhack-2023
Primary language: Python

![logo](logo.png)

## Inspiration

Preserving personal legacies is an ongoing concern for many. As time passes, memories fade, voices are lost, and the essence of individuals can become distant.

## What it does

Our solution offers a unique way to overcome this by enabling individuals to create personalized conversational AI models, ensuring that your legacy—your voice, stories, and personality—endures beyond your lifetime, providing comfort and connection to your loved ones in the future.

## How we built it

The tool works in 2 stages:
1. Building a persona by having a conversation/answering questions (GPT to generate questions, text-to-speech to ask questions, speech-to-text to register responses). The audio + content is then used to personalise a GPT
2. Having a casual chat with the generated persona (speech-to-text to register the user’s conversation, GPT with persona to generate response, text-to-speech to give responses with the mimicked voice)

## Challenges we ran into

- Figuring out API calls
- Working out how to have a fluent conversation with the chatbot (e.g. how long to wait to respond etc.)
- Slow model generation since we need real-time conversations

## What we learned

- Require high-quality recordings to have good voice-mimicking
- Many models are inherently biased (e.g. text-to-speech models were quite good overall but added a slight American accent to most voices)

## Accomplishments that we're proud of

- Implementing a working end-to-end prototype that performs quite well considering the time we had
- Empowering users to leave behind a digital legacy, aiding in the bereavement process for their loved ones.

## What's next for Legacy LM

- Refining the voice mimicry and persona adoption
- Building it out into a user-friendly tool
- Improving conversation latency to sound more fluent
- Expand into other use cases of personalised GPTs (e.g. personal memoirs)

## Built With

Python, Hugging Face, OpenAI, ElevenLabs
Repository: laushack/pathfinder
Primary language: Kotlin

# LauzHack 2023
![P+R Pathfinder](thumbnail.jpg "P+R Pathfinder")
## Authors
- Alexandre Piveteau
- Matthieu Burguburu
- Victor Schneuwly
- Zacharie Tevaearai

## Organization

This project is built using Compose for Web and Kotlin multiplatform. It is split into 3 modules:

- `common`, which contains the common code between the client and the server;
- `frontend`, which contains the client code; and
- `backend`, which contains the server code.

The code is formatted using Ktfmt. You can install it as an IntelliJ plugin.

## Running the project

The project is built using Gradle. To run the project, you can use the following commands:

```bash
./gradlew run # Starts the server, on port 8888
./gradlew jsBrowserDevelopmentRun --continuous # Starts the client on port 8080
```

You'll need an OpenAI API key to run the project. You generate one [here](https://platform.openai.com/api-keys). 

Once you have an api key and you have credits on your account, you can set it as an environment variable:

```bash
export OPENAI_API_KEY='your_api_key'
```
Repository: leonielc/sudoFocus
Primary language: HTML

# Bug Tracker Web Application

A simple Flask web application to register buggy code, document fixes, and analyze new code to find similar issues.

## Features

- **Register Bugs**: Save buggy code snippets with descriptions and fix instructions
- **Analyze Code**: Submit code to check against the database for similar bugs
- **Similarity Matching**: Uses text similarity algorithms to find matching buggy code patterns
- **SQLite Database**: Lightweight database to store all bug records

## Installation

1. Install Python 3.7 or higher

2. Install dependencies:
```bash
pip install -r requirements.txt
```

## Running the Application

1. Start the Flask server:
```bash
python app.py
```

2. Open your browser and go to:
```
http://127.0.0.1:5000
```

## Usage

### Register a Bug
1. Click "Register a Bug" on the home page
2. Fill in:
   - **Bug Name**: A descriptive name for the bug
   - **Buggy Code**: The problematic code snippet
   - **How to Fix**: Description of the fix or corrected code
3. Click "Register Bug"

### Analyze Code
1. Click "Analyze Code" on the home page
2. Paste the code you want to check
3. Click "Analyze Code"
4. View results showing similar bugs and their fixes (60%+ similarity threshold)

## Project Structure

```
sudoGTD/
├── app.py                 # Main Flask application
├── templates/
│   ├── index.html        # Home page
│   ├── register.html     # Bug registration page
│   └── query.html        # Code analysis page
├── requirements.txt       # Python dependencies
└── bugs.db               # SQLite database (created automatically)
```

## API Endpoints

- `GET /` - Home page
- `GET /register` - Bug registration form
- `POST /api/register` - Register a new bug (JSON)
- `GET /query` - Code analysis form
- `POST /api/query` - Analyze code (JSON)
- `GET /api/bugs` - Get all bugs (JSON)

## Technologies

- **Backend**: Flask (Python)
- **Database**: SQLite
- **Frontend**: HTML, CSS, JavaScript
- **Similarity Algorithm**: SequenceMatcher from Python's difflib
Repository: lh-anarhic-rift-team/launch
Primary language: Shell

# FocusMirror

Cognitive safety for the age of infinite scroll

## Basic idea

App to track your focus and to provide a viable and easy to use outlet for you to understand your habbits better!!!

We used Oracle Agent Spec for our llm connectors

Utilized image analysis to identify common habits onscreen, and imporove the lives of Developers () all around the world!

## Why are we better than any other tracker?

We provide functionallity and storage completelly locally, its up to you to decide what secvices to use with our integration.

## Running locally

To launch the app use this command

    launch.sh
Repository: logilinux/logilinux
Primary language: C++

# LogiLinux - Logitech Device Library for Linux

A C++ library and tools for interfacing with Logitech Creator devices on Linux, including the MX Dialpad and MX Keypad. This was made for LauzHack 2025.

## What is This?

LogiLinux provides a clean C++ library (liblogilinux) for working with Logitech input devices on Linux. It handles device discovery, event monitoring, and provides a type-safe API for building applications.

## Quick Start

### Building

```bash
./build.sh
```

Or manually:

```bash
mkdir build && cd build
cmake ..
make -j$(nproc)
```

### Running Examples

```bash
sudo ./build/examples/dialpad-example
sudo ./build/examples/mx-keypad-example  
sudo ./build/examples/volume-example
```

## Key Discovery

The MX Dialpad works as a standard Linux input device and sends events through the input subsystem. When you rotate the dial, it sends:

- REL_HWHEEL (axis 6): Low-resolution steps (1-6 units per tick)
- REL_MISC (axis 12): High-resolution angle (120 units per degree)
- Positive values = clockwise, negative = counter-clockwise

## Using the Library

### Simple Example

```cpp
#include <logilinux/logilinux.h>
#include <logilinux/events.h>

void onEvent(LogiLinux::EventPtr event) {
    if (auto rotation = std::dynamic_pointer_cast<LogiLinux::RotationEvent>(event)) {
        std::cout << "Rotated: " << rotation->delta << " steps" << std::endl;
    }
    if (auto button = std::dynamic_pointer_cast<LogiLinux::ButtonEvent>(event)) {
        std::cout << "Button " << button->button_code << (button->pressed ? " pressed" : " released") << std::endl;
    }
}

int main() {
    LogiLinux::Library lib;
    auto device = lib.findDevice(LogiLinux::DeviceType::DIALPAD);  // or MX_KEYPAD

    device->setEventCallback(onEvent);
    device->startMonitoring();

    return 0;
}
```

Compile with:

```bash
g++ -std=c++17 myapp.cpp $(pkg-config --cflags --libs logilinux)
```

See `lib/README.md` for full API documentation.

## Prerequisites

```bash
sudo apt-get install build-essential cmake libudev-dev
sudo dnf install gcc-c++ cmake libudev-devel
sudo pacman -S base-devel cmake systemd
```

## Permissions

To avoid using sudo:

```bash
sudo bash -c 'cat > /etc/udev/rules.d/99-logitech.rules << EOF
SUBSYSTEM=="hidraw", KERNEL=="hidraw*", ATTRS{idVendor}=="046d", ATTRS{idProduct}=="bc00", MODE="0666"
EOF'

sudo udevadm control --reload-rules
sudo udevadm trigger
```

## Supported Devices

### MX Dialpad
- Model: Logitech MX Dialpad  
- Vendor ID: `046d` (Logitech)
- Product ID: `bc00`
- Features: Rotation, button press, high-resolution scrolling
- Protocol: HID++ 4.5

### MX Keypad
- Model: Logitech MX Creative Console / MX Keypad
- Vendor ID: `046d` (Logitech) 
- Features: 9 programmable LCD buttons, navigation buttons
- Capabilities: Button events, LCD image display, JPEG upload
Repository: lola-monroy/hypertension_appill
Primary language: TypeScript

# APPILL
# Medication and Tension Monitoring App
This project is designed to assist elderly users in managing their medication and monitoring health data through a cross-platform mobile app. It integrates pill shape detection, hypertension prediction, and smartwatch data simulation.
## Key Features
- **Add Medication Information**: Users can add basic information like dosage, and schedule.
- **Verify Medication Taken**: By taking a picture of the pill, the app will apply computer vision operations to ensure that the correct pill has been taken.
- **Secure Data Storage**: We store user data in a secure way, localy, to ensure privacy.
- **Hypertension Risk Prediction**: Machine learning model predicts the likelihood of hypertension using health metrics, keeping them simple without doing overkill.
- **Smartwatch Data Simulation**: Generates simulated health data, including heart rate, variability, and steps, for health tracking and alerts.

## Technologies Used
- **React Native:** For building a cross-platform mobile app with a simple and intuitive interface, designed for elderly users.
- **MATLAB (Image Processing):** Used to prototype pill recognition algorithms based on basic morphological operations like erosions and contour detection. Later converted to a python script for better manipulation. 
- **Python:** Backend implementation of image processing algorithms, transitioning from MATLAB for better integration with the app and scalability.

## File structure
### Main Project
- apill/: app, components, assets, hooks, scripts: Mobile app code written in React Native.
        package.json & package-lock.json: Dependency management for the mobile app​
- tsconfig.json: TypeScript configuration for the app.
- README.md: Documentation for the project

### Counting pills
- count_python.py: Script for detecting and counting pills using OpenCV and scikit-image​
- pillX.jpeg: Sample pill images for testing.
- count_matlab.m & count_matlab_note.mlx: MATLAB scripts for prototyping pill recognition algorithms.

### Hypertension prediction
- data_hypertension/hypertension_data.csv: Dataset for training the hypertension prediction model.
tension/:
- hypertension_model.h5: Saved trained model.
- model_training.py: Model training script using TensorFlow/Keras​
- prediccions.py: Flask API for making predictions​
- scaler.save: Scaler object for data normalization.

### Smartwatch simulation 
- smartwatch.py: Simulates smartwatch data for health metrics like heart rate and steps​.

## Future Improvements
- **Accessibility Features**: Provide audio instructions for better accessibility.
- **Take the photo on the spot**: Instead of having to upload it from computer.


## Contributing
If you want to contribute, please fork the repository, make your changes, and submit a pull request. We welcome all improvements and suggestions!

## License
This project is licensed under the MIT License.