diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6d3990fc..d8c28384 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -28,6 +28,10 @@ All notable changes to the *readme-ai* project will be documented in this file.
- Update configuration [ignore_files.toml](https://github.com/eli64s/readme-ai/blob/main/readmeai/conf/ignore_files.toml) to stop ignoring the following file extensions:
- yaml, toml, txt, lock
+### ๐งน Chore
+
+- Regenerate all README files in the [examples](https://github.com/eli64s/readme-ai/tree/main/examples) directory to reflect the latest changes to the tool.
+
---
## [v0.0.9] - *2023-09-19*
diff --git a/README.md b/README.md
index f1c3e7d5..34650f86 100644
--- a/README.md
+++ b/README.md
@@ -69,9 +69,11 @@ This project is currently under development and has an opinionated configuration
@@ -84,15 +86,18 @@ This project is currently under development and has an opinionated configuration
|
|
|
+
|
@@ -114,7 +119,9 @@ This project is currently under development and has an opinionated configuration
- 
+
+
+ |
@@ -123,17 +130,19 @@ This project is currently under development and has an opinionated configuration
- โฆ Intro, Badges, & Table of Contents
+ โฆ Introduction, Badges, & Table of Contents
- The OpenAI API is prompted to create a 1-sentence phrase describing your project.
- Project dependencies and metadata are visualized using Shields.io badges.
- - Badges are sorted by hex code, displayed from light to dark hues.
+
|
- 
+
+
+ |
@@ -156,12 +165,16 @@ This project is currently under development and has an opinionated configuration
- 
+
+
+ |
- 
+
+
+ |
@@ -170,7 +183,9 @@ This project is currently under development and has an opinionated configuration
- 
+
+
+ |
@@ -193,7 +208,9 @@ This project is currently under development and has an opinionated configuration
- 
+
+
+ |
@@ -202,7 +219,9 @@ This project is currently under development and has an opinionated configuration
- 
+
+
+ |
diff --git a/examples/readme-fastapi-redis.md b/examples/readme-fastapi-redis.md
index 397ab4b1..2f8f4303 100644
--- a/examples/readme-fastapi-redis.md
+++ b/examples/readme-fastapi-redis.md
@@ -1,11 +1,9 @@
-
-
-async-ml-inference
+
async-ml-inference
-
โฆ Real-time ML magic, with async-ml-inference!
+
โฆ Fast, Reliable AI: async-ml-inference
โฆ Developed with the software and tools listed below.
@@ -23,23 +21,25 @@ async-ml-inference
-
-
-
-
-
+
+
+
+
---
-## ๐ Table of Contents
-- [๐ Table of Contents](#-table-of-contents)
+## ๐ Table of Contents
+- [๐ Table of Contents](#-table-of-contents)
- [๐ Overview](#-overview)
-- [โ๏ธ Features](#-features)
-- [๐ Project Structure](#project-structure)
-- [๐งฉ Modules](#modules)
+- [๐ฆ Features](#-features)
+- [๐ Repository Structure](#-repository-structure)
+- [โ๏ธ Modules](#modules)
- [๐ Getting Started](#-getting-started)
-- [๐บ Roadmap](#-roadmap)
+ - [๐ง Installation](#-installation)
+ - [๐ค Running async-ml-inference](#-running-async-ml-inference)
+ - [๐งช Tests](#-tests)
+- [๐ฃ Roadmap](#-roadmap)
- [๐ค Contributing](#-contributing)
- [๐ License](#-license)
- [๐ Acknowledgments](#-acknowledgments)
@@ -49,29 +49,29 @@ async-ml-inference
## ๐ Overview
-The project is a complete end-to-end solution for asynchronous machine learning inference, including an API for task creation and retrieval, workers for processing tasks, and a client for interacting with the API. It supports task processing for audio file length extraction and EuroMillions results scraping. The project leverages the capabilities of Celery and Redis for efficient background task processing and deploys the components using Docker containers for easy deployment and scalability. It enables users to offload computationally expensive tasks to workers, improving the performance and efficiency of machine learning inference tasks.
+The project aims to provide an asynchronous machine learning inference system using distributed task management and a web API. It includes components for processing audio lengths and scraping EuroMillions results. The system offers the ability to handle background tasks, retrieve task results, and supports parallel processing for increased efficiency. Its value lies in enabling efficient and scalable inference, making it suitable for applications that require real-time processing of audio data and retrieval of scraped information.
---
-## โ๏ธ Features
-
-| Feature | Description |
-| ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **โ๏ธ Architecture** | The codebase follows a microservices architecture with separate components for the API, workers, and client. The API uses FastAPI for handling HTTP requests and Celery for background task processing. The workers are responsible for executing specific tasks asynchronously. |
-| **๐ Documentation** | The codebase lacks comprehensive documentation. While there are some comments in the code, there is no overall documentation describing the system's architecture, design patterns, or usage instructions. A more thorough explanation of the code and its components would be helpful for understanding and maintaining the system. |
-| **๐ Dependencies** | The system relies on several external libraries, including FastAPI, Redis, RabbitMQ, Celery, Beautiful Soup, and Kombu. These dependencies provide functionality for handling HTTP requests, background task processing, handling data from Redis, and scraping data from websites. |
-| **๐งฉ Modularity** | The codebase is organized into smaller components with separate directories for the API, workers, and client. Each directory contains code specific to its functionality, making it relatively easy to modify or replace individual components without impacting the overall system. |
-| **โ๏ธ Testing** | The codebase does not include any tests. The lack of tests makes it difficult to ensure the correctness and reliability of the system. Implementing a testing strategy, including unit and integration tests, would greatly improve the codebase's stability and maintainability. |
-| **โก๏ธ Performance** | The performance of the system highly depends on external systems like Redis and RabbitMQ for task queuing and message passing. The codebase itself does not have significant performance bottlenecks. However, the presence of long task processing times in the workers could impact overall performance. |
-| **๐ Security** | The codebase does not include any explicit security measures. It is important to harden the system components, such as Redis and RabbitMQ, with appropriate access controls and authentication mechanisms to protect the data and ensure the system's security. |
-| **๐ Version Control** | The codebase is hosted on GitHub, utilizing Git for version control. This allows for collaboration, tracking changes, and maintaining different branches for development and releases. |
-| **๐ Integrations** | The system integrates with Redis and RabbitMQ for efficient task processing, Celery for executing background tasks, and Beautiful Soup and Kombu for scraping website data and handling message passing. Additional integrations could be added to expand the system's functionality. |
-| **๐ถ Scalability** | The system's architecture allows for horizontal scalability by adding more instances of the API, workers, or client components. The use of queue-based task processing and microservices architecture enables scaling the different components independently to handle increased
+## ๐ฆ Features
+
+| Feature | Description |
+| ---------------------- | ------------------------------------- |
+| **โ๏ธ Architecture** | The codebase follows a microservices architecture, with separate services for RabbitMQ message broker, Redis backend, Celery workers, API service, and client service. The services are connected via a network. The use of Docker Compose allows for easy setup and management of the multi-container environment.
+| **๐ Documentation** | The codebase lacks comprehensive documentation. While some files contain brief descriptions of their purpose, there is no central documentation or README file providing an overview of the project's features and usage. Further documentation would benefit developers trying to understand and contribute to the project.
+| **๐ Dependencies** | The codebase relies on various external libraries and systems. Some notable dependencies include BeautifulSoup, Celery, FastAPI, RabbitMQ, Redis, and Uvicorn. These libraries provide functionality for web scraping, distributed task management, API development, message queuing, and backend storage. The dependencies are specified in the Pipfile and Pipfile.lock files.
+| **๐งฉ Modularity** | The codebase demonstrates modularity by organizing components into separate directories (api and workers), each containing their own set of files. This separation allows for easy understanding and maintenance of each component. The code also makes use of modular libraries like Celery and FastAPI, enabling the creation of interchangeable components.
+| **๐งช Testing** | The codebase does not include explicit testing strategies and tools. However, the modular design of the components allows for easier testing and isolation of functionality. Developers can implement unit tests for individual components by mocking dependencies and using test frameworks like pytest.
+| **โก๏ธ Performance** | The performance of the system depends on the efficiency of the individual components. The use of Celery for distributed task management and Redis for backend storage helps improve the system's speed and resource usage. However, specific performance benchmarks or optimization techniques are not mentioned in the codebase.
+| **๐ Security** | The codebase does not explicitly address security measures. However, potential security concerns include the handling of user credentials for RabbitMQ and Redis connections, as well as the validation and sanitization of user inputs in the API endpoints. The code could benefit from the implementation of authentication and authorization mechanisms to protect sensitive data.
+| **๐ Version Control** | The codebase uses Git for version control, as evidenced by the presence of a .gitignore file and the GitHub repository itself. However, the code lacks versioning information, such as tags or release notes, to indicate the progression and history of the project. Proper use of branching and pull requests would facilitate collaborative development and code review processes.
+| **๐ Integrations** | The system interacts with external systems like RabbitMQ and Redis for message queuing and backend storage, respectively. It also utilizes external libraries like BeautifulSoup for web scraping and requests for making HTTP requests. The modular design of the codebase allows for easy integration with other services or APIs as needed.
+| **๐ถ Scalability** | The use of a microservices architecture with separate components allows for scalability by adding or removing services based on demand. The codebase shows potential for horizontal scalability by replicating and load balancing the worker services. However, the code does not incorporate explicit scalability features, such as auto-scaling or dynamic resource allocation.
---
-## ๐ Project Structure
+## ๐ Repository Structure
```bash
@@ -112,59 +112,64 @@ repo
---
-## ๐งฉ Modules
+## โ๏ธ Modules
Root
-| File | Summary |
-| --- | --- |
-| [Pipfile](https://github.com/FerrariDG/async-ml-inference/blob/main/Pipfile) | The provided code snippet is a configuration file that specifies dependencies, scripts, and URLs for a project. It includes package versions, development packages, script commands for running various components (e.g., brokers, workers), and URLs for accessing resources (e.g., PyPI). |
+| File | Summary |
+| --- | --- |
+| [docker-compose.yaml](https://github.com/FerrariDG/async-ml-inference/blob/main/docker-compose.yaml) | This code sets up a multi-container environment using Docker Compose. It includes a RabbitMQ message broker, a Redis backend, Celery workers for audio and euro tasks, an API service, and a client service. The services are connected via a network. |
+| [Pipfile](https://github.com/FerrariDG/async-ml-inference/blob/main/Pipfile) | This code defines package dependencies, scripts for running various components, and their versions. It includes libraries like BeautifulSoup, Celery, FastAPI, and others, with corresponding versions specified. It also sets up scripts for running components like RabbitMQ, Redis, Flower, and Celery workers. Finally, it includes a script for running the API and a client script. |
+| [Pipfile.lock](https://github.com/FerrariDG/async-ml-inference/blob/main/Pipfile.lock) | HTTPStatus Exception: 400 |
Api
-| File | Summary |
-| --- | --- |
-| [Dockerfile](https://github.com/FerrariDG/async-ml-inference/blob/main/src/api/Dockerfile) | This code sets up the environment for a Python API. It installs the required dependencies, copies the API code, exposes the necessary ports, and starts the API server using Uvicorn. |
-| [api.py](https://github.com/FerrariDG/async-ml-inference/blob/main/src/api/api.py) | This code snippet sets up a FastAPI application with Celery and Redis for background task processing. It defines two API routes for creating and retrieving tasks. The tasks are sent to the Celery worker and their results are stored in Redis. The code also includes a function to send the task results. |
+| File | Summary |
+| --- | --- |
+| [requirements.txt](https://github.com/FerrariDG/async-ml-inference/blob/main/src/api/requirements.txt) | The code utilizes Celery for distributed task management, FastAPI for building APIs, and Uvicorn as the ASGI server. Pydantic is used for data validation and serialization. |
+| [Dockerfile](https://github.com/FerrariDG/async-ml-inference/blob/main/src/api/Dockerfile) | This code sets up a Python web API using the FastAPI framework. It installs required dependencies, copies the API code, and exposes ports for communication. Finally, it runs the API using Uvicorn with specific host and port configurations. |
+| [api.py](https://github.com/FerrariDG/async-ml-inference/blob/main/src/api/api.py) | This code sets up a FastAPI server that interacts with Celery to handle background tasks. It defines two endpoints for creating tasks, and a third endpoint to get the result of a task by its ID. The code also includes a helper function to send task results to an external destination. |
Workers
-| File | Summary |
-| --- | --- |
-| [backend.py](https://github.com/FerrariDG/async-ml-inference/blob/main/src/workers/backend.py) | The code snippet provides functions to retrieve Redis connection details (host, port, password, and database) from environment variables, construct a Redis URL, and check if a Redis instance is running. |
-| [Dockerfile](https://github.com/FerrariDG/async-ml-inference/blob/main/src/workers/Dockerfile) | This code snippet sets up a Python environment for workers. It installs necessary dependencies, upgrades pip, and installs packages from a requirements.txt file. It copies the code into the workers directory, exposes ports 6379 and 5672. |
-| [broker.py](https://github.com/FerrariDG/async-ml-inference/blob/main/src/workers/broker.py) | The code snippet provides functions to retrieve the RabbitMQ connection details, construct the broker URL, and check if the broker is running. It retrieves environment variables for customization and utilizes the kombu library for connection handling. |
+| File | Summary |
+| --- | --- |
+| [backend.py](https://github.com/FerrariDG/async-ml-inference/blob/main/src/workers/backend.py) | The code includes functions to retrieve Redis connection details from environment variables, construct a Redis connection URL, and check if the Redis backend is running by attempting a connection. The code promotes flexibility and reusability by allowing easy customization of Redis connection settings. |
+| [requirements.txt](https://github.com/FerrariDG/async-ml-inference/blob/main/src/workers/requirements.txt) | The code utilizes the BeautifulSoup4 library for web scraping, Celery with Redis for task management, Librosa for audio analysis, and Numba for just-in-time compilation. |
+| [Dockerfile](https://github.com/FerrariDG/async-ml-inference/blob/main/src/workers/Dockerfile) | This code sets up a Python environment, installs required dependencies, and copies the code into a working directory. It also exposes ports 6379 and 5672. |
+| [broker.py](https://github.com/FerrariDG/async-ml-inference/blob/main/src/workers/broker.py) | This code provides functions to get the RabbitMQ connection URL, check if the RabbitMQ broker is running, and handle connection errors. It uses environment variables for user credentials, host, port, and vhost. |
Audio
-| File | Summary |
-| --- | --- |
-| [worker.py](https://github.com/FerrariDG/async-ml-inference/blob/main/src/workers/audio/worker.py) | This code snippet defines a Celery worker that extracts the length of an audio file. It checks if the backend and broker are running, then fetches the audio file from a URL. It loads the audio data, calculates the length, and simulates a long task processing time. Finally, it returns the audio length. |
-| [config.py](https://github.com/FerrariDG/async-ml-inference/blob/main/src/workers/audio/config.py) | This code snippet includes configuration settings for a Celery worker that processes audio files. It sets the worker to acknowledge tasks only when they are returned or fail, limits the worker to handle only one task at a time, creates a queue for audio tasks, and sets the expiration time for Redis keys to 48 hours. |
+| File | Summary |
+| --- | --- |
+| [worker.py](https://github.com/FerrariDG/async-ml-inference/blob/main/src/workers/audio/worker.py) | This code defines a Celery worker for extracting the length of an audio file from a given URL. It validates the running status of the backend and broker, retrieves the audio data, and calculates the length using librosa. The task is executed asynchronously. |
+| [config.py](https://github.com/FerrariDG/async-ml-inference/blob/main/src/workers/audio/config.py) | This module configures the Celery worker for processing audio lengths. It sets the worker to acknowledge tasks only when they complete or fail, allows the worker to process only one task at a time, creates a queue for the worker, and sets the expiration time for Redis keys to 48 hours. |
Euro
-| File | Summary |
-| --- | --- |
-| [worker.py](https://github.com/FerrariDG/async-ml-inference/blob/main/src/workers/euro/worker.py) | This code snippet is a Celery worker that scrapes Euromillions results from a website. It checks the status of the backend and broker services, then defines a task called "scrappy_result" that takes a draw date as input. It opens the corresponding URL, parses the HTML using Beautiful Soup, extracts the numbers and stars, and returns them as a tuple. |
-| [config.py](https://github.com/FerrariDG/async-ml-inference/blob/main/src/workers/euro/config.py) | The code snippet configures Celery for a EuroMillions Results worker. It enables late task acknowledgements, sets worker prefetch multiplier to 1, creates a single queue named "euro", and sets the result expiration time to 48 hours. |
+| File | Summary |
+| --- | --- |
+| [worker.py](https://github.com/FerrariDG/async-ml-inference/blob/main/src/workers/euro/worker.py) | This code is a Celery worker that scrapes the Euromillions website for results. It checks if the backend and broker services are running, then defines a task to scrape the results for a given draw date. It handles exceptions and returns the numbers and stars from the scraped page. |
+| [config.py](https://github.com/FerrariDG/async-ml-inference/blob/main/src/workers/euro/config.py) | This module sets up Celery configurations for the Euromillions Results worker, including task acknowledgements, prefetching, queue name, and result expiration time. It ensures efficient task processing and result management. |
Client
-| File | Summary |
-| --- | --- |
-| [Dockerfile](https://github.com/FerrariDG/async-ml-inference/blob/main/src/client/Dockerfile) | The given code creates a Docker container for a Python client application. It installs required dependencies, copies the application files, exposes port 5000, and sets the startup command as'python client.py'. |
-| [client.py](https://github.com/FerrariDG/async-ml-inference/blob/main/src/client/client.py) | This code snippet sends requests to an API with audio URLs and dates, retrieves task IDs, and then retrieves the corresponding results. It uses parallel processing for efficiency. |
+| File | Summary |
+| --- | --- |
+| [requirements.txt](https://github.com/FerrariDG/async-ml-inference/blob/main/src/client/requirements.txt) | This code uses the requests library to make HTTP requests, retrying library to handle retry logic, and joblib library for parallel processing. |
+| [Dockerfile](https://github.com/FerrariDG/async-ml-inference/blob/main/src/client/Dockerfile) | This code sets up a Python environment, installs project dependencies, and copies a Python script. It then exposes port 5000 and runs the script when the container starts. |
+| [client.py](https://github.com/FerrariDG/async-ml-inference/blob/main/src/client/client.py) | This code sends audio URLs and dates to an API, retrieves task IDs, and then retrieves the results of those tasks using parallel processing. It also handles retrying requests and printing the results. |
-
-docker-gs-ping
+
docker-gs-ping
-
โฆ Seamless pinging with docker-gs-ping!
+
โฆ Containerize the Ping!
โฆ Developed with the software and tools listed below.
@@ -14,23 +12,25 @@ docker-gs-ping
-
-
-
-
-
+
+
+
+
---
-## ๐ Table of Contents
-- [๐ Table of Contents](#-table-of-contents)
+## ๐ Table of Contents
+- [๐ Table of Contents](#-table-of-contents)
- [๐ Overview](#-overview)
-- [โ๏ธ Features](#-features)
-- [๐ Project Structure](#project-structure)
-- [๐งฉ Modules](#modules)
+- [๐ฆ Features](#-features)
+- [๐ Repository Structure](#-repository-structure)
+- [โ๏ธ Modules](#modules)
- [๐ Getting Started](#-getting-started)
-- [๐บ Roadmap](#-roadmap)
+ - [๐ง Installation](#-installation)
+ - [๐ค Running docker-gs-ping](#-running-docker-gs-ping)
+ - [๐งช Tests](#-tests)
+- [๐ฃ Roadmap](#-roadmap)
- [๐ค Contributing](#-contributing)
- [๐ License](#-license)
- [๐ Acknowledgments](#-acknowledgments)
@@ -40,29 +40,29 @@ docker-gs-ping
## ๐ Overview
-The project is a Dockerized Go server that responds to HTTP requests using the Echo framework. It serves as a basic web server with middleware setup, customizable routes, and the ability to handle different HTTP methods. The project's value proposition lies in providing a lightweight, scalable, and easily deployable server solution, allowing developers to quickly set up and handle HTTP requests with minimal configuration.
+The project is a Docker image that pings a server using a simple Go web application built with the Echo framework. It provides a lightweight and portable solution for checking the connectivity of a server. The Dockerization allows for easy deployment and scalability, making it convenient for monitoring multiple servers in a distributed environment. Additionally, the inclusion of automated tests and continuous integration workflows ensures the reliability and quality of the application.
---
-## โ๏ธ Features
-
-| Feature | Description |
-| ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
-| **โ๏ธ Architecture** | The codebase follows a simple and straightforward architectural design, with a single web server using the Echo framework to handle HTTP requests. |
-| **๐ Documentation** | The documentation is limited, with only brief summaries of each file in the repository. It would be beneficial to have more detailed documentation, including instructions on setup and usage. |
-| **๐ Dependencies** | The codebase relies on external libraries, such as Echo for the web framework, and other Go modules managed through the go.mod file. |
-| **๐งฉ Modularity** | The system is organized into smaller components, with separate files for the main server, unit tests, Dockerfiles, and the go.mod file. The modularity allows for easy extensibility and maintenance. |
-| **โ๏ธ Testing** | The code includes automated unit tests using Go's testing package, covering different scenarios and assertions for the main server and the IntMin function. |
-| **โก๏ธ Performance** | The system's performance depends on the underlying Go framework and the hardware it is deployed on. The minimalistic Dockerfile ensures a lean image, minimizing resource usage. |
-| **๐ Security** | The codebase doesn't explicitly implement security measures. However, being a straightforward server, implementing additional security measures would depend on the deployment and specific requirements. |
-| **๐ Version Control** | The codebase is version-controlled using Git, hosted on GitHub. The repository can be cloned or forked, and any changes can be tracked and managed effectively using Git methodologies. |
-| **๐ Integrations** | The system does not have explicit integrations, but it can be easily integrated with other systems or services through HTTP endpoints provided by the Echo framework. |
-| **๐ถ Scalability** | The system's scalability depends on the underlying Go framework and the infrastructure it is deployed on. Being a simple web server, it can handle a moderate level of concurrent requests. |
+## ๐ฆ Features
+
+| Feature | Description |
+| ---------------------- | ------------------------------------- |
+| **โ๏ธ Architecture** | The codebase follows a modular architecture with separate files for different components of the application. It uses the Echo framework to set up an HTTP server and handle routes. The Dockerfiles provide containerization for the application. Limit your response to a maximum of 250 characters. |
+| **๐ Documentation** | The codebase is relatively well-documented, with each file providing a brief summary of its purpose. However, more detailed comments within the code could improve comprehensiveness. Limit your response to a maximum of 250 characters. |
+| **๐ Dependencies** | The project relies on the Echo framework, as well as several other Go modules that are specified in the `go.mod` file. These dependencies provide the necessary functionality for building the web application and running tests. Limit your response to a maximum of 250 characters. |
+| **๐งฉ Modularity** | The codebase demonstrates good modularity by separating concerns into different files. The main functionality is contained in the `main.go` file, while testing logic resides in `main_test.go`. The Dockerfiles provide flexibility for building and deploying the application. Limit your response to a maximum of 250 characters. |
+| **๐งช Testing** | The codebase includes test functions for the `IntMin` function using a basic scenario and a table-driven approach. This ensures that the function behaves as expected under different input conditions. The GitHub Actions workflows enable automated testing and provide visibility into the test results. Limit your response to a maximum of 250 characters. |
+| **โก๏ธ Performance** | The codebase doesn't include explicit performance optimizations. However, being a simple web application, it is expected to have good performance. The use of the Echo framework and Go's concurrency features can contribute to efficient request handling. Limit your response to a maximum of 250 characters. |
+| **๐ Security** | The codebase does not explicitly address security measures. However, Go and Docker have built-in security features, and using frameworks like Echo can help mitigate common security vulnerabilities. Proper input validation and secure handling of sensitive data should be implemented if required. Limit your response to a maximum of 250 characters. |
+| **๐ Version Control** | The codebase uses Git for version control, with the repository hosted on GitHub. The project follows a standard branching model, with CI/CD workflows triggered on push events and new tags. It leverages GitHub Actions for automated build, test, and release processes. Limit your response to a maximum of 250 characters. |
+| **๐ Integrations** | The codebase integrates with GitHub Actions for continuous integration and deployment. It builds and tests the application in containers, caches layers, and pushes releases to Docker Hub. The integration enables efficient development workflow and easy deployment. Limit your response to a maximum of 250 characters. |
+| **๐ถ Scalability** | The codebase doesn't explicitly address scalability. However, being a containerized application, it can be easily deployed on scalable container orchestration platforms like Kubernetes. The modular design allows components to be scaled independently, and the use of Go can contribute to handling high loads. Limit your response to a maximum of 250 characters. |
---
-## ๐ Project Structure
+## ๐ Repository Structure
```bash
@@ -81,17 +81,26 @@ repo
---
-## ๐งฉ Modules
+## โ๏ธ Modules
Root
-| File | Summary |
-| --- | --- |
-| [go.mod](https://github.com/olliefr/docker-gs-ping/blob/main/go.mod) | The code snippet is a Go module that uses the Echo framework to build a server that responds to HTTP requests. It has various dependencies managed with version requirements. |
-| [Dockerfile](https://github.com/olliefr/docker-gs-ping/blob/main/Dockerfile) | The provided code snippet builds a Docker image for a Go application. It downloads Go modules, copies the source code, builds the application, and exposes port 8080. Finally, it sets the command to run the built application. |
-| [Dockerfile.multistage](https://github.com/olliefr/docker-gs-ping/blob/main/Dockerfile.multistage) | The provided code snippet is a Dockerfile that builds a Go application, runs tests, and creates a lean image for deployment. It first builds the application, downloads dependencies, and compiles the binary. Then, it runs tests in a separate stage. Finally, it creates an image using a minimal base, copies the binary, opens a port, sets a non-root user, and sets the entry point as the binary. |
-| [main.go](https://github.com/olliefr/docker-gs-ping/blob/main/main.go) | This code snippet is a basic web server built with the Echo framework. It sets up middleware, defines two routes ("/" and "/health"), and starts the server on a specified port (defaulting to 8080). It also includes a simple function for finding the minimum of two integers. |
-| [main_test.go](https://github.com/olliefr/docker-gs-ping/blob/main/main_test.go) | The code snippet is a demonstration of automated unit testing in Go. It includes two test functions, one using basic assertions and the other using table-driven testing. The functions test the IntMin function by comparing its output with expected values and reporting any mismatches. |
+| File | Summary |
+| --- | --- |
+| [go.mod](https://github.com/olliefr/docker-gs-ping/blob/main/go.mod) | This code module is for a Docker image that pings a server. It requires the Echo framework and several other dependencies. |
+| [Dockerfile](https://github.com/olliefr/docker-gs-ping/blob/main/Dockerfile) | The code sets up a Docker environment for a Go application. It downloads Go modules, copies the source code, builds the application, exposes port 8080, and runs the application. |
+| [Dockerfile.multistage](https://github.com/olliefr/docker-gs-ping/blob/main/Dockerfile.multistage) | This Dockerfile builds a Go application from source, runs tests inside a container, and then deploys the application into a lean image based on the distroless base image. The final image exposes port 8080 and executes the application as the nonroot user. |
+| [main.go](https://github.com/olliefr/docker-gs-ping/blob/main/main.go) | This code is a simple Go web application using the Echo framework. It sets up an HTTP server, handles routes for root and health endpoints, and starts the server on the specified port. It also includes a function to find the minimum of two integers. |
+| [main_test.go](https://github.com/olliefr/docker-gs-ping/blob/main/main_test.go) | This code includes two test functions for the IntMin function. The first test checks a basic scenario, while the second uses a table-driven approach to test multiple inputs and expected outputs. |
+
+Workflows
+
+| File | Summary |
+| --- | --- |
+| [ci-cd.yml](https://github.com/olliefr/docker-gs-ping/blob/main/.github/workflows/ci-cd.yml) | This code is for a GitHub Actions workflow that runs on push events to the main branch or when a new tag is created. It builds and tests an application in a Docker container, caches Docker layers, and pushes the release to Docker Hub if the event is not a pull request. It uses Docker Buildx and Docker login to handle the build and push process. |
+| [ci-smoketest.yml](https://github.com/olliefr/docker-gs-ping/blob/main/.github/workflows/ci-smoketest.yml) | This code sets up a smoke test for a Go project. It runs automatically on every push to the repository or can be triggered manually. The test will build and test the project using Go toolchain in a GitHub runner. |
-
-Minimal-Todo
+
Minimal-Todo
-
โฆ Maximize productivity, minimize clutter!
+
โฆ Maximize your productivity with Minimal-Todo!
โฆ Developed with the software and tools listed below.
-
+
-
-
-
-
-
+
+
+
+
---
-## ๐ Table of Contents
-- [๐ Table of Contents](#-table-of-contents)
+## ๐ Table of Contents
+- [๐ Table of Contents](#-table-of-contents)
- [๐ Overview](#-overview)
-- [โ๏ธ Features](#-features)
-- [๐ Project Structure](#project-structure)
-- [๐งฉ Modules](#modules)
+- [๐ฆ Features](#-features)
+- [๐ Repository Structure](#-repository-structure)
+- [โ๏ธ Modules](#modules)
- [๐ Getting Started](#-getting-started)
-- [๐บ Roadmap](#-roadmap)
+ - [๐ง Installation](#-installation)
+ - [๐ค Running Minimal-Todo](#-running-Minimal-Todo)
+ - [๐งช Tests](#-tests)
+- [๐ฃ Roadmap](#-roadmap)
- [๐ค Contributing](#-contributing)
- [๐ License](#-license)
- [๐ Acknowledgments](#-acknowledgments)
@@ -40,29 +40,29 @@ Minimal-Todo
## ๐ Overview
-The Minimal-Todo project is an Android app that allows users to create and manage a list of to-do items. It provides features such as creating and editing reminders, setting custom colors for items, and storing data locally. The app focuses on simplicity and minimalism, offering a clean and intuitive user interface. Its value proposition lies in its ability to help users stay organized and conveniently manage their tasks on their mobile devices.
+The Minimal-Todo project is an Android application that allows users to create and manage a to-do list. The core functionalities include adding new tasks, setting reminders, and customizing settings. The app aims to provide a minimalist and intuitive interface for users to efficiently organize their tasks and increase productivity. Its value proposition lies in its simplicity, ease of use, and ability to help users stay organized and focused.
---
-## โ๏ธ Features
-
-| Feature | Description |
-| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **โ๏ธ Architecture** | The system follows the Model-View-Presenter (MVP) architectural pattern. The MVP pattern separates the concerns and provides better maintainability and testability. |
-| **๐ Documentation** | The codebase includes some documentation in the form of comments, but it could be improved in terms of clarity and coverage. |
-| **๐ Dependencies** | The project relies on external libraries like ButterKnife for view binding and Google services for various functionalities. |
-| **๐งฉ Modularity** | The system is well organized into smaller components like activities, fragments, and utility classes. The modular structure facilitates reusability and maintainability. |
-| **โ๏ธ Testing** | The codebase includes test classes that cover various use cases, such as data storage and manipulation. The tests are written using the JUnit and Espresso frameworks, ensuring functional correctness. |
-| **โก๏ธ Performance** | The system performs well, with no significant performance issues reported. It uses efficient data structures and follows best practices for resource handling. |
-| **๐ Security** | The system uses secure data storage methods and does not expose sensitive information. However, further measures, such as encryption, could enhance security. |
-| **๐ Version Control** | The system is version controlled using Git, and the codebase is hosted on GitHub. It allows for collaborative development and easy tracking of changes and bug fixes. |
-| **๐ Integrations** | The system integrates with Google Analytics to track user actions. It also interacts with Android's built-in notification system and preferences for enhanced user experience. |
-| **๐ถ Scalability** | The system's modular design and efficient resource handling make it capable of handling growth. However, further optimizations may be required for larger datasets and increased user traffic. |
+## ๐ฆ Features
+
+| Feature | Description |
+| ---------------------- | ------------------------------------- |
+| **โ๏ธ Architecture** | The codebase follows a typical Model-View-Controller (MVC) architecture. The app module contains the main functionality of the application, including the user interface, data handling, and other crucial components. The code is well-organized and follows the separation of concerns principle, making it easy to maintain and extend. |
+| **๐ Documentation** | The codebase has well-documented comments that explain the purpose and functionality of each class and method. However, there is no comprehensive documentation outside of code comments, which could make it challenging for new contributors to understand the project. |
+| **๐ Dependencies** | The codebase relies on several external libraries, including Butterknife for view binding, Google services for various functionalities, and libraries for analytics, UI components, and support. These libraries enhance the functionality and user experience of the application. |
+| **๐งฉ Modularity** | The codebase is modular and organized into smaller components with clear responsibilities. Each class focuses on a specific functionality, such as settings management, task reminders, or data storage. This modularity allows for easier maintenance, testing, and reusability of code. |
+| **๐งช Testing** | The codebase includes a comprehensive set of unit tests and functional tests. The tests cover critical functionalities such as writing and reading data to/from storage, creating and updating to-do items, and handling preferences. The use of JUnit and Android testing frameworks ensures the reliability and correctness of the code. |
+| **โก๏ธ Performance** | The performance of the system is satisfactory, with efficient resource usage. The codebase utilizes background services for tasks like creating and displaying notifications, ensuring that these operations do not impact the user experience. However, further performance optimizations can be implemented, such as asynchronous operations for data handling and caching mechanisms for improved responsiveness. |
+| **๐ Security** | The codebase lacks explicit security measures, such as data encryption or user authentication. However, it does not handle sensitive data and is primarily focused on personal task management, which lowers the security risks. Implementing security measures like data encryption and authentication would be necessary if the application expands its scope to handle sensitive information. |
+| **๐ Version Control** | The codebase uses Git for version control, as evident from the repository on GitHub. The use of version control allows for efficient collaboration, code management, and tracking of changes. The repository follows best practices, including meaningful commit messages and branching strategies. |
+| **๐ Integrations** | The system does not have any notable integrations with external systems or services beyond the use of Google services for analytics. It primarily focuses on providing a standalone to-do list app experience without relying on external data sources or services. There is potential for future integrations, such as cloud sync or third-party APIs, to enhance the functionality. |
+| **๐ถ Scalability** | The codebase does not currently demonstrate explicit scalability considerations. However, due to its modular structure and separation of concerns, it should be relatively straightforward to extend and add new features. Scalability can be further enhanced by implementing data synchronization mechanisms or utilizing backend services for handling larger datasets or multiple users. |
---
-## ๐ Project Structure
+## ๐ Repository Structure
```bash
@@ -300,111 +300,114 @@ repo
---
-## ๐งฉ Modules
+## โ๏ธ Modules
Root
-| File | Summary |
-| --- | --- |
-| [build.gradle](https://github.com/avjinder/Minimal-Todo/blob/main/build.gradle) | The code snippet configures the build settings for an Android project, including adding dependencies, repositories, and plugins. It utilizes Gradle to manage the build process and includes support for Google services and ButterKnife. |
-| [gradlew.bat](https://github.com/avjinder/Minimal-Todo/blob/main/gradlew.bat) | This code snippet is a Gradle startup script for Windows that sets up the environment, finds Java, and executes Gradle with the specified command line arguments. |
-| [settings.gradle](https://github.com/avjinder/Minimal-Todo/blob/main/settings.gradle) | The provided code snippet includes the':app' module, indicating that it includes the main application code for the project. |
+| File | Summary |
+| --- | --- |
+| [build.gradle](https://github.com/avjinder/Minimal-Todo/blob/main/build.gradle) | This code is a build file that configures the dependencies and repositories for an Android project. It includes the necessary dependencies for Android build tools and Google services. It also sets up Butterknife for view binding. |
+| [gradlew.bat](https://github.com/avjinder/Minimal-Todo/blob/main/gradlew.bat) | This code is a Windows startup script for running Gradle. It sets up the environment variables and finds the Java executable. It then executes Gradle with the specified arguments and classpath. |
+| [settings.gradle](https://github.com/avjinder/Minimal-Todo/blob/main/settings.gradle) | The code provides the core functionalities for the app module, which is likely the main functionality of the application. It encompasses the necessary code to run the app, including the user interface, data handling, and any other crucial components. |
+| [.travis.yml](https://github.com/avjinder/Minimal-Todo/blob/main/.travis.yml) | This code sets up the necessary components and tools for an Android project, including build tools and the Android platform version. It also includes dependencies for Google Play Services and the Android Support Repository. The before_script ensures executable permission for the Gradle wrapper, and the script runs the build process with Gradle. |
App
-| File | Summary |
-| --- | --- |
-| [build.gradle](https://github.com/avjinder/Minimal-Todo/blob/main/app/build.gradle) | This code snippet sets up an Android application. It defines the app's configuration, including the application ID, version info, and minimum/target SDK versions. It configures the release build type with minification and proguard. It also sets up dependencies for various libraries used in the app. |
+| File | Summary |
+| --- | --- |
+| [build.gradle](https://github.com/avjinder/Minimal-Todo/blob/main/app/build.gradle) | This code is for an Android application. It sets up the build configurations and dependencies, including plugins for signing, Google services, and various libraries for analytics, UI components, and support. |
Minimaltodo
-| File | Summary |
-| --- | --- |
-| [TestStoreRetrieveData.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/androidTest/java/com/example/avjindersinghsekhon/minimaltodo/TestStoreRetrieveData.java) | The code snippet is a set of test cases for the StoreRetrieveData class. It tests the functionality of writing and reading data to/from storage, as well as the conversion of ArrayList to JSONArray. |
-| [ApplicationTest.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/androidTest/java/com/example/avjindersinghsekhon/minimaltodo/ApplicationTest.java) | This code snippet is an Android application testing class that extends the ApplicationTestCase class. It is used for fundamental testing of the application's functions and components. |
-| [TestTodoItem.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/androidTest/java/com/example/avjindersinghsekhon/minimaltodo/TestTodoItem.java) | This code snippet is a test class that verifies the functionality of the ToDoItem class. It includes tests for constructing a ToDoItem, marshalling to JSON, and unmarshalling from JSON. The tests verify that the correct data is set and retrieved in each scenario. |
+| File | Summary |
+| --- | --- |
+| [TestStoreRetrieveData.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/androidTest/java/com/example/avjindersinghsekhon/minimaltodo/TestStoreRetrieveData.java) | The code is a test suite for the StoreRetrieveData class. It tests the functionality of writing and reading data to and from storage, ensuring that the stored data matches the test data. It also includes a test for the conversion of the test data to a JSONArray. |
+| [ApplicationTest.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/androidTest/java/com/example/avjindersinghsekhon/minimaltodo/ApplicationTest.java) | The code is a test case for an Android application. It extends the ApplicationTestCase class and tests various fundamentals of the application. |
+| [TestTodoItem.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/androidTest/java/com/example/avjindersinghsekhon/minimaltodo/TestTodoItem.java) | The code consists of JUnit tests for the ToDoItem class. It tests the three-parameter constructor, marshalling of objects to JSON, and unmarshalling of objects from JSON. The tests verify the functionality of the ToDoItem class by checking if the constructed objects match the expected values. |
Settings
-| File | Summary |
-| --- | --- |
-| [SettingsFragment.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Settings/SettingsFragment.java) | The code snippet defines a SettingsFragment class that extends PreferenceFragment. It creates preferences layout from preferences_layout.xml file and initializes some variables. It listens for changes in shared preferences and handles the night mode preference by updating the theme and recreating the activity. It also registers and unregisters the preference change listener. |
-| [SettingsActivity.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Settings/SettingsActivity.java) | This code snippet is for a SettingsActivity class in an Android app. It sets the theme based on user preferences, sets up the toolbar with a back arrow, and displays the SettingsFragment. It also handles the home button click to navigate up. |
+| File | Summary |
+| --- | --- |
+| [SettingsFragment.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Settings/SettingsFragment.java) | The SettingsFragment class is responsible for managing the preferences and settings of the app. It handles the creation and initialization of preferences, detects changes in preferences, and updates the app's theme and layout accordingly. It also registers and unregisters itself as a shared preference change listener to ensure proper functioning. |
+| [SettingsActivity.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Settings/SettingsActivity.java) | This code defines the functionality of the SettingsActivity in an Android app. It sets the theme based on user preference, sets up the toolbar, handles navigation back to the parent activity, and loads the SettingsFragment. It also includes analytics tracking. |
Reminder
-| File | Summary |
-| --- | --- |
-| [ReminderFragment.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Reminder/ReminderFragment.java) | This code snippet is for a ReminderFragment in a to-do list app. It handles the creation, editing, and removal of reminders for individual to-do items. It also provides options for snoozing reminders and saving data. The code includes functionality for setting the theme, handling button clicks, and navigating between activities. |
-| [ReminderActivity.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Reminder/ReminderActivity.java) | The provided code snippet is a class for the ReminderActivity in an Android app. It extends AppDefaultActivity and implements methods for creating the layout and initial fragment for the activity. The layout is set to reminder_layout and the initial fragment is created from the ReminderFragment class. |
+| File | Summary |
+| --- | --- |
+| [ReminderFragment.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Reminder/ReminderFragment.java) | This code is for the Reminder functionality in a todo list app. It allows the user to view and modify reminders for specific tasks. The code handles snoozing reminders, removing tasks from the reminder list, and saving changes to the data. It also includes functionality for switching between light and dark themes. |
+| [ReminderActivity.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Reminder/ReminderActivity.java) | This code defines the ReminderActivity class, which extends AppDefaultActivity. It sets the layout, creates the initial fragment, and handles the creation of the activity. |
About
-| File | Summary |
-| --- | --- |
-| [AboutActivity.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/About/AboutActivity.java) | The provided code snippet represents an Android activity class called "AboutActivity." It is responsible for displaying information about the application. The activity includes functionality for retrieving and displaying the app version, setting the toolbar with a back arrow, handling menu item selection events, and navigating back to the parent activity. It also includes theme handling based on user preferences. |
-| [AboutFragment.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/About/AboutFragment.java) | This code snippet represents an implementation of an About Fragment in an Android app. It sets up the UI elements, such as a toolbar and contact me button, and sets the app version. It also initializes analytics functionality and sends events when the contact me button is clicked. |
+| File | Summary |
+| --- | --- |
+| [AboutActivity.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/About/AboutActivity.java) | The code is for an AboutActivity in a to-do list app. It sets the theme, displays the app version, and handles the toolbar. It also creates the initial fragment and handles the back button press. |
+| [AboutFragment.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/About/AboutFragment.java) | The AboutFragment class is responsible for displaying information about the app. It sets up the UI elements such as version number and toolbar. It also handles user interaction for contacting the developer and tracks analytics events using the AnalyticsApplication class. The class extends AppDefaultFragment and overrides the layoutRes() method to specify the fragment's layout file. It provides a static newInstance() method to create an instance of the fragment. |
Addtodo
-| File | Summary |
-| --- | --- |
-| [AddToDoActivity.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/AddToDo/AddToDoActivity.java) | The code snippet is for an Android activity called AddToDoActivity. It extends a custom AppDefaultActivity and overrides methods for handling the activity's creation, content view layout, and initial fragment creation. |
+| File | Summary |
+| --- | --- |
+| [AddToDoFragment.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/AddToDo/AddToDoFragment.java) | HTTPStatus Exception: 400 |
+| [AddToDoActivity.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/AddToDo/AddToDoActivity.java) | The code defines an activity that allows users to add a new to-do item. It extends a custom base activity and sets the layout for the activity. It also creates and displays the initial fragment for adding the to-do item. |
Main
-| File | Summary |
-| --- | --- |
-| [MainActivity.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Main/MainActivity.java) | The code snippet is for the MainActivity of a Minimal Todo app. It sets up the toolbar, inflates the layout, creates the initial fragment, and handles menu item clicks for about me and preferences. |
-| [CustomRecyclerScrollViewListener.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Main/CustomRecyclerScrollViewListener.java) | This code snippet defines an abstract class called CustomRecyclerScrollViewListener that extends RecyclerView.OnScrollListener. It implements scroll behavior for RecyclerView, allowing the hiding and showing of elements based on scroll distance. The abstract methods show() and hide() need to be implemented by subclasses to define specific actions when showing or hiding elements. |
+| File | Summary |
+| --- | --- |
+| [MainActivity.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Main/MainActivity.java) | The code defines the main activity for a to-do list app. It includes a toolbar, menu options for about, settings, and theme switch, and handles the navigation between activities. |
+| [CustomRecyclerScrollViewListener.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Main/CustomRecyclerScrollViewListener.java) | This code defines a custom RecyclerView scroll listener that tracks the scroll distance and toggles the visibility of a view based on the scroll direction and distance. It provides abstract methods to show or hide the view. |
+| [MainFragment.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Main/MainFragment.java) | HTTPStatus Exception: 400 |
Analytics
-| File | Summary |
-| --- | --- |
-| [AnalyticsApplication.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Analytics/AnalyticsApplication.java) | This code snippet defines an Application class that implements Google Analytics. It tracks user actions and sends analytics events to the server. The class provides methods to send screen views and events with optional parameters like category, action, and label. It also sets up the analytics tracker with the app name and exception reporting. |
+| File | Summary |
+| --- | --- |
+| [AnalyticsApplication.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Analytics/AnalyticsApplication.java) | The code represents an Android application that incorporates Google Analytics for tracking user interactions and events. It initializes and configures the Google Analytics tracker, and provides methods for sending screen views and custom events. The code also handles exception reporting and app identification. |
Appdefault
-| File | Summary |
-| --- | --- |
-| [AppDefaultFragment.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/AppDefault/AppDefaultFragment.java) | The code snippet is a base class called AppDefaultFragment that extends the Fragment class. It provides a common implementation for onCreateView() and onDestroy() methods. The abstract method layoutRes() is used to get the layout resource for the fragment. |
-| [AppDefaultActivity.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/AppDefault/AppDefaultActivity.java) | The provided code snippet is a template for creating an activity in an Android app. It extends the AppCompatActivity class and sets the content view layout for the activity. It also provides methods to set up the initial fragment and define the layout resource and initial fragment for subclasses. |
+| File | Summary |
+| --- | --- |
+| [AppDefaultFragment.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/AppDefault/AppDefaultFragment.java) | The code defines a generic Fragment class that provides a default implementation for creating and destroying a Fragment's view. The specific layout resource to be inflated is determined by subclasses. |
+| [AppDefaultActivity.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/AppDefault/AppDefaultActivity.java) | The code defines an abstract activity class that sets up a fragment container and initializes an initial fragment based on the subclass implementation. The activity also sets the contentViewLayoutRes and creates the initial fragment. |
Utility
-| File | Summary |
-| --- | --- |
-| [TodoNotificationService.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/TodoNotificationService.java) | The provided code snippet represents a service that generates and displays a notification. It receives a to-do text and a unique identifier as input, creates a notification with the to-do text as its content, and sets up a pending intent for handling the notification interactions. The service also includes a delete intent for deleting the notification. |
-| [ScrollingFABBehaviour.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/ScrollingFABBehaviour.java) | The code snippet defines a custom behavior for a FloatingActionButton in a CoordinatorLayout. It allows the FAB to react to changes in its dependent views (Snackbar and Toolbar) by adjusting its translation based on their positions. |
-| [ToDoItem.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/ToDoItem.java) | The provided code snippet is a class called ToDoItem. It represents a todo item with properties such as todo text, reminder status, description, color, date, and unique identifier. It has methods to initialize, serialize and deserialize the todo item as a JSON object. |
-| [CustomTextInputLayout.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/CustomTextInputLayout.java) | The provided code snippet is for a custom TextInputLayout widget that extends the original TextInputLayout from the support library. It overrides some methods, such as addView() and onDraw(), in order to handle the setting and resetting of hint values for EditTexts and ensure that the hint is displayed correctly. Overall, it customizes the behavior of TextInputLayout for specific use cases. |
-| [StoreRetrieveData.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/StoreRetrieveData.java) | The code snippet provides a class called StoreRetrieveData which supports storing and retrieving data from a file in JSON format. It can convert a list of ToDoItems into a JSONArray, save it to a file, and load it back into an ArrayList. The class uses Android's Context for file operations. |
-| [Utils.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/Utils.java) | The provided code defines a utility class that contains a method to obtain the toolbar height from the application's context. It retrieves the toolbar height by accessing the "actionBarSize" attribute from the app's theme resources. The method returns the obtained toolbar height. |
-| [DeleteNotificationService.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/DeleteNotificationService.java) | The provided code is a service that deletes a notification identified by a UUID from a list of ToDoItems. It loads the list from storage, identifies the item to be deleted, removes it from the list, saves the updated list, and notifies the application that the data has changed. |
-| [ItemTouchHelperClass.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/ItemTouchHelperClass.java) | This code snippet defines a class called `ItemTouchHelperClass` that extends `ItemTouchHelper.Callback`. It provides functionality for dragging and swiping items in a `RecyclerView`. It implements methods for moving items, removing items, and configuring the drag and swipe behaviors. |
-| [PreferenceKeys.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/PreferenceKeys.java) | The code snippet defines a class that manages the preferences keys used in the app. The main functionality is to retrieve and store the resource key for the night mode preference. |
-| [RecyclerViewEmptySupport.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/RecyclerViewEmptySupport.java) | The provided code snippet is a class called RecyclerViewEmptySupport. It extends the RecyclerView class and adds the functionality to display an empty view when the RecyclerView is empty. The class includes methods to show the empty view, set the empty view, and handle changes in the adapter data to show or hide the empty view accordingly. |
+| File | Summary |
+| --- | --- |
+| [TodoNotificationService.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/TodoNotificationService.java) | The code defines a service for creating and displaying notifications. It takes in a todo text and UUID as input, creates a notification with the text as the content, and sets up intents for certain actions. The notification is then displayed using the NotificationManager. |
+| [ScrollingFABBehaviour.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/ScrollingFABBehaviour.java) | The code defines a custom behavior for a FloatingActionButton in a CoordinatorLayout. It handles the hiding and showing of the FloatingActionButton based on the scroll position of its dependencies, such as a Snackbar or a Toolbar. The FloatingActionButton is translated vertically based on the position of the dependencies. |
+| [ToDoItem.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/ToDoItem.java) | This code defines a ToDoItem class that represents a task in a to-do list. It includes properties such as the task text, description, reminder status, color, and due date. The class also provides methods to serialize/deserialize the object to JSON format. |
+| [CustomTextInputLayout.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/CustomTextInputLayout.java) | The CustomTextInputLayout class extends the TextInputLayout class and provides additional functionality for handling the hint text of an EditText. It stores the original hint value locally and sets it on the TextInputLayout when drawing the view. This ensures that the hint is preserved even if it is changed programmatically. |
+| [StoreRetrieveData.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/StoreRetrieveData.java) | The StoreRetrieveData class provides methods for saving and loading data to/from a file. It can convert a list of ToDoItem objects to a JSON array and save it to a file. It can also load a JSON array from a file and convert it back to a list of ToDoItem objects. |
+| [Utils.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/Utils.java) | This code provides a utility function to get the height of the toolbar in an Android application. It uses the context and styled attributes to obtain the toolbar height dynamically from the theme resources. The function returns the toolbar height as an integer value. |
+| [DeleteNotificationService.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/DeleteNotificationService.java) | The code is an Android service that handles the deletion of a notification for a to-do item. It loads the data, identifies the item to be deleted based on its unique identifier, removes it from the list, and saves the updated data. It also notifies the app that a change has occurred. |
+| [ItemTouchHelperClass.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/ItemTouchHelperClass.java) | This code defines a class that extends ItemTouchHelper.Callback to handle swipe and drag functionalities in a RecyclerView. It provides methods to enable long press drag, item view swipe, and defines movement flags. It also includes callback methods for handling item movement and removal. |
+| [PreferenceKeys.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/PreferenceKeys.java) | The code defines a utility class that holds the preference keys used in a minimalist to-do app. It includes a constructor that initializes the night mode preference key using the app's resources. |
+| [RecyclerViewEmptySupport.java](https://github.com/avjinder/Minimal-Todo/blob/main/app/src/main/java/com/example/avjindersinghsekhon/minimaltodo/Utility/RecyclerViewEmptySupport.java) | The code provides a custom implementation of a RecyclerView with support for an empty view. It allows the user to set an empty view that is displayed when the RecyclerView adapter has no items. The empty view is automatically hidden or shown based on the adapter's item count. The code also contains methods to handle changes in the adapter's data and update the empty view accordingly. |
-
-assistant-chat-gpt
+
assistant-chat-gpt
-
โฆ Bringing AI chat to life!
+
โฆ Chat smarter with GPT: Your AI assistant for GitHub!
โฆ Developed with the software and tools listed below.
@@ -20,23 +18,25 @@ assistant-chat-gpt
-
-
-
-
-
+
+
+
+
---
-## ๐ Table of Contents
-- [๐ Table of Contents](#-table-of-contents)
+## ๐ Table of Contents
+- [๐ Table of Contents](#-table-of-contents)
- [๐ Overview](#-overview)
-- [โ๏ธ Features](#-features)
-- [๐ Project Structure](#project-structure)
-- [๐งฉ Modules](#modules)
+- [๐ฆ Features](#-features)
+- [๐ Repository Structure](#-repository-structure)
+- [โ๏ธ Modules](#modules)
- [๐ Getting Started](#-getting-started)
-- [๐บ Roadmap](#-roadmap)
+ - [๐ง Installation](#-installation)
+ - [๐ค Running assistant-chat-gpt](#-running-assistant-chat-gpt)
+ - [๐งช Tests](#-tests)
+- [๐ฃ Roadmap](#-roadmap)
- [๐ค Contributing](#-contributing)
- [๐ License](#-license)
- [๐ Acknowledgments](#-acknowledgments)
@@ -46,29 +46,28 @@ assistant-chat-gpt
## ๐ Overview
-The project is a web application that serves as a voice assistant using OpenAI's ChatGPT and the Web Speech API. The codebase includes components for managing user input, rendering chat interfaces, and providing information about the assistant. It supports voice input and output, real-time chat history, and various settings options. The project aims to provide an intuitive and interactive interface for users to interact with ChatGPT and receive spoken responses, enhancing the experience of using a voice assistant.
+The project is a voice-controlled AI assistant that provides a chat interface for users. It utilizes speech recognition to listen for commands and retrieves answers from a chatbot API. The assistant also includes features such as voice synthesis for speaking responses and the ability to customize settings such as voice selection and filler words. The project aims to provide a user-friendly and interactive way for users to interact with the AI assistant, enhancing their productivity and convenience.
---
-## โ๏ธ Features
+## ๐ฆ Features
| Feature | Description |
| ---------------------- | ------------------------------------- |
-| **โ๏ธ Architecture** | The codebase follows a modular architecture, with separate folders for different components and functionalities such as background, popup, content, and components. The background script listens to events, while the popup and content scripts handle UI interactions. The communication between these components is done through the messaging system provided by Chrome extensions.
-| **๐ Documentation** | The repository lacks comprehensive documentation. While some files have brief comments and explanations, there is no dedicated documentation detailing the system's usage, design patterns, or architectural decisions.
-| **๐ Dependencies** | The codebase relies on various external packages, including React, ReactDOM, Sass, esbuild, archiver, and react-toggle. These libraries provide support for UI rendering, CSS styling, package bundling, and toggle functionality. The OpenAI API is used for the ChatGPT integration.
-| **๐งฉ Modularity** | The system is organized into smaller, interchangeable components, making it easier to understand and maintain. Each component has a specific responsibility, such as handling background events, rendering UI, managing settings, and communicating with third-party APIs.
-| **โ๏ธ Testing** | There is no explicit mention of testing in the repository. The absence of testing files or scripts indicates that testing may not be practiced extensively in this codebase.
-| **โก๏ธ Performance** | Performance cannot be fully assessed without analyzing the entire codebase. However, based on the provided summaries, the codebase seems to handle speech recognition, speech synthesis, and chat interactions efficiently using Web Speech API and OpenAI's ChatGPT.
-| **๐ Security** | The codebase does not explicitly detail security measures, but it handles authentication with the OpenAI API. It's important to ensure that user data is handled securely, especially for a chat assistant that may process sensitive information.
-| **๐ Version Control** | The codebase is hosted on GitHub, suggesting the use of Git for version control. However, further analysis is required to evaluate the specific version control strategies or practices implemented.
-| **๐ Integrations** | The codebase interacts with Chrome extensions' APIs for browser events and UI rendering. It also integrates with the OpenAI API for natural language processing and the Web Speech API for speech recognition and synthesis.
-| **๐ถ Scalability** | Scalability cannot be determined without a more detailed analysis. However, the use of modular components and external APIs allows for flexibility and potential scalability in handling additional features or expanding the system's functionality.
+| **โ๏ธ Architecture** | The codebase follows a modular architecture with separate components for different functionalities such as background, popup, content, and components. The use of React components allows for easy reusability and composition. The codebase also includes event-driven programming with listeners and callbacks to handle user interactions and system events. Overall, the architecture is well-structured and organized. |
+| **๐ Documentation** | The codebase has limited documentation. While some files have brief comments explaining their functionality, there is no comprehensive documentation or README file explaining the overall project, its features, and how to set it up or contribute to it. Improved documentation would make it easier for developers to understand and contribute to the project. |
+| **๐ Dependencies** | The codebase relies on several external dependencies, including esbuild, esbuild-sass-plugin, softprops/action-gh-release, ReactDOM, and various React libraries. These dependencies provide critical functionality such as transpilation, bundling, release automation, rendering React components, and managing CSS. The use of these dependencies enhances productivity and allows for the adoption of best practices. |
+| **๐งฉ Modularity** | The codebase exhibits good modularity by organizing functionality into smaller, interchangeable components. Each component is responsible for a specific task, such as background, popup, content, or components. This modular approach enhances maintainability, reusability, and testability. However, some components could benefit from further decoupling and separation of concerns to improve code readability and ease of maintenance. |
+| **๐งช Testing** | The codebase does not include any testing strategies or tools. The lack of tests makes it difficult to ensure the correctness and stability of the codebase. Incorporating testing frameworks such as Jest or Cypress and writing unit tests and end-to-end tests would significantly improve the quality and reliability of the project. |
+| **โก๏ธ Performance** | The performance of the system depends on various factors such as the efficiency of the external libraries used and the complexity of the logic implemented. Without performance-specific code or benchmarks, it is difficult to make definitive claims about the system's performance. However, leveraging tools like performance profiling and optimization techniques can help in ensuring efficient resource utilization and optimal speed. |
+| **๐ Security** | The codebase does not have explicit security measures mentioned in the provided information. Given that this is an AI chatbot assistant system, it is crucial to consider security aspects such as handling user inputs, protecting sensitive data, and securing communication with external APIs. Implementing measures like input validation, secure communication protocols (HTTPS), and user authentication can enhance the security of the system. |
+| **๐ Version Control** | The codebase uses Git for version control. The presence of a GitHub repository suggests the use of Git workflows and branch management. The provided information does not mention specific version control strategies or tools being used. The adoption of branching models like GitFlow and utilizing features like pull requests and code reviews can enhance collaboration and code quality. |
+| **๐ Integrations** | The codebase integrates with external systems and services such as Chrome and Firefox browsers, chatbot APIs, and the browser's speech synthesis API. The integration with these systems allows for enhanced functionality and features like voice-controlled AI
---
-## ๐ Project Structure
+## ๐ Repository Structure
```bash
@@ -110,57 +109,66 @@ repo
---
-## ๐งฉ Modules
+## โ๏ธ Modules
Root
-| File | Summary |
-| --- | --- |
-| [build.mjs](https://github.com/idosal/assistant-chat-gpt/blob/main/build.mjs) | The code snippet uses esbuild and archiver libraries to build and package a web application. It compiles various entry points, applies plugins (including a Sass plugin), minifies the code, and creates a build directory. It then zips the necessary files into separate archives for Chrome and Firefox extensions. |
+| File | Summary |
+| --- | --- |
+| [build.mjs](https://github.com/idosal/assistant-chat-gpt/blob/main/build.mjs) | This code performs the following functionalities:1. Deletes the old build directory2. Uses esbuild to transpile and bundle JavaScript code3. Converts Sass files to CSS using esbuild-sass-plugin4. Zips the generated files into a zip archive for Chromium5. (currently commented out) Zips the generated files for Firefox as well |
+| [.prettierrc.yaml](https://github.com/idosal/assistant-chat-gpt/blob/main/.prettierrc.yaml) | The code implements core functionalities with semicolon formatting turned off and the use of single quotes enabled. |
+
+Workflows
+
+| File | Summary |
+| --- | --- |
+| [release.yml](https://github.com/idosal/assistant-chat-gpt/blob/main/.github/workflows/release.yml) | This code is a GitHub Actions workflow that runs on push events. It checks out the code, sets up Node.js, installs dependencies, builds the code, and then releases a Chrome zip file using the softprops/action-gh-release action, generating release notes if the push event is for a new tag. |
Background
-| File | Summary |
-| --- | --- |
-| [index.mjs](https://github.com/idosal/assistant-chat-gpt/blob/main/src/background/index.mjs) | The code snippet sets up an event listener for when Chrome starts up and logs a message. It also opens the options page of the extension when called. |
+| File | Summary |
+| --- | --- |
+| [index.mjs](https://github.com/idosal/assistant-chat-gpt/blob/main/src/background/index.mjs) | This code sets up an event listener that triggers a console log message ('onStartup') when the Chrome browser starts up. It also opens the Chrome options page. |
Popup
-| File | Summary |
-| --- | --- |
-| [index.html](https://github.com/idosal/assistant-chat-gpt/blob/main/src/popup/index.html) | The provided code snippet is an HTML document that defines a CSS style sheet and includes a JavaScript module file. It sets up the structure and styling for a web page, with specific formatting for different color schemes. It also contains a container element with an ID "app" where a JavaScript application can be loaded and executed. |
-| [index.mjs](https://github.com/idosal/assistant-chat-gpt/blob/main/src/popup/index.mjs) | The code imports React and ReactDOM libraries and the Popup component. It uses ReactDOM to render the Popup component to the "app" id element. This code sets up a root app element and renders a popup component onto it. |
+| File | Summary |
+| --- | --- |
+| [index.html](https://github.com/idosal/assistant-chat-gpt/blob/main/src/popup/index.html) | The code is an HTML template for a web page. It includes CSS styles to customize the appearance and a JavaScript file to add functionality. The web page has a container element with an ID of "app". The CSS styles define variables for colors and set the background color and font styles. The JavaScript file, "index.js", likely contains code to manipulate the DOM and add interactive features to the web page. |
+| [index.mjs](https://github.com/idosal/assistant-chat-gpt/blob/main/src/popup/index.mjs) | This code sets up and renders a React component called "Popup" using ReactDOM, allowing it to be displayed on the web page. |
Content
-| File | Summary |
-| --- | --- |
-| [index.html](https://github.com/idosal/assistant-chat-gpt/blob/main/src/content/index.html) | This code snippet is an HTML document with embedded CSS styles. It sets various CSS variables for different color schemes (light and dark) and defines styles for different elements such as headings, paragraphs, buttons, and callouts with different colors. It also includes links to external JavaScript files that are commented out. |
-| [audio.mjs](https://github.com/idosal/assistant-chat-gpt/blob/main/src/content/audio.mjs) | This code snippet sets up a voice assistant using Web Speech API and OpenAI's ChatGPT. It listens for user speech input, sends it to ChatGPT for processing, and generates a spoken response. It also handles authentication, history tracking, and system events. |
-| [fetch-sse.mjs](https://github.com/idosal/assistant-chat-gpt/blob/main/src/content/fetch-sse.mjs) | The provided code snippet is a function that uses the fetch API to retrieve server-sent events (SSE) from a specified resource. It creates an eventsource-parser to parse the SSE data and calls the onMessage callback for each event received. It uses a streamAsyncIterable function to iterate over the response body in chunks and feeds them to the parser. |
-| [app.css](https://github.com/idosal/assistant-chat-gpt/blob/main/src/content/app.css) | The code snippet is a function that takes in a list of numbers and returns the sum of all odd numbers in the list. It uses a loop to iterate over each number in the list, checks if it is odd, and adds it to a running total. Finally, it returns the total sum of the odd numbers. |
-| [info.mjs](https://github.com/idosal/assistant-chat-gpt/blob/main/src/content/info.mjs) | The code imports React and ReactDOM libraries, as well as the Info component. It uses ReactDOM's createRoot method to render the Info component on the root element of the HTML document. The Info component is created using the React.createElement function. |
-| [index.mjs](https://github.com/idosal/assistant-chat-gpt/blob/main/src/content/index.mjs) | The code snippet imports two modules,'info' and'audio', providing access to their respective functionalities. |
-| [stream-async-iterable.mjs](https://github.com/idosal/assistant-chat-gpt/blob/main/src/content/stream-async-iterable.mjs) | The code snippet provides a function called "streamAsyncIterable" which takes a stream as input and returns an async iterable. It uses the stream's reader object to read data asynchronously in a looping fashion. It yields data until the reader is done or until there is no more data to read. Finally, it releases the lock of the reader. |
+| File | Summary |
+| --- | --- |
+| [index.html](https://github.com/idosal/assistant-chat-gpt/blob/main/src/content/index.html) | The code is an HTML template with CSS styling. It defines the visual layout and appearance of a web page. It includes color variables, media queries for dark mode, and various styles for headings, paragraphs, callouts, buttons, and animations. The JavaScript file "index.js" is also linked to the page. The code aims to create an aesthetically pleasing and functional web interface. |
+| [audio.mjs](https://github.com/idosal/assistant-chat-gpt/blob/main/src/content/audio.mjs) | This code is a voice-controlled AI assistant. It uses speech recognition to listen for commands, retrieves answers from a chatbot API, and speaks the responses back using speech synthesis. It also includes features such as pause fillers and voice selection. |
+| [fetch-sse.mjs](https://github.com/idosal/assistant-chat-gpt/blob/main/src/content/fetch-sse.mjs) | This code fetches server-sent events (SSE) from a specified resource. It uses the Fetch API to make the request and receives the response. It then uses an eventsource-parser library to parse the SSE messages and calls the onMessage callback for each event received. The response body is streamed using a custom streamAsyncIterable function, and the parsed data is fed into the parser. |
+| [app.css](https://github.com/idosal/assistant-chat-gpt/blob/main/src/content/app.css) | The code provides core functionalities for a software application. It ensures smooth execution, manages data storage and retrieval, handles user input and provides output, and maintains system security. Additionally, it enables integration with external systems, facilitates communication between different components, and supports efficient processing of tasks. Overall, the code serves as the backbone of the application, enabling its reliable and efficient operation. |
+| [info.mjs](https://github.com/idosal/assistant-chat-gpt/blob/main/src/content/info.mjs) | This code is rendering a React component called Info to the DOM element with the id of "root". It utilizes the ReactDOM.createRoot method to enable Concurrent Mode rendering in React. |
+| [index.mjs](https://github.com/idosal/assistant-chat-gpt/blob/main/src/content/index.mjs) | The code imports the modules'info.mjs' and'audio.mjs'. It encompasses functionality related to gathering information and managing audio. |
+| [stream-async-iterable.mjs](https://github.com/idosal/assistant-chat-gpt/blob/main/src/content/stream-async-iterable.mjs) | This code defines a async generator function that takes a stream as input. It uses the stream's reader to continuously read data chunks until the stream is done. It yields each chunk of data while the stream is active. Finally, it releases the reader's lock when the process is done. |
Components
-| File | Summary |
-| --- | --- |
-| [TriggerInput.jsx](https://github.com/idosal/assistant-chat-gpt/blob/main/src/components/TriggerInput.jsx) | This code snippet is for a VoiceDropdown component in a React application. It allows the user to set a trigger phrase which is stored and displayed in an input field. The onChange event updates the trigger value and invokes the setTriggerPhrase function with the updated trigger value. |
-| [Popup.jsx](https://github.com/idosal/assistant-chat-gpt/blob/main/src/components/Popup.jsx) | This code snippet is a React component that renders a chat UI for a chat assistant. It retrieves chat history from a Chrome extension and displays messages in a MessageList component. The component uses useRef and useEffect hooks to handle scrolling and update the chat history. |
-| [Callout.jsx](https://github.com/idosal/assistant-chat-gpt/blob/main/src/components/Callout.jsx) | This code exports a React component called Callout. It takes two props: type (defines the styling) and children (the content inside the Callout component). It returns a div element with the classNames'callout' and the type prop, containing the children. |
-| [Info.jsx](https://github.com/idosal/assistant-chat-gpt/blob/main/src/components/Info.jsx) | This code snippet is for a React component called "Info". It renders a page with information about a voice assistant called ChassistantGPT. The component checks if the user is using Chrome and if the microphone permission is granted. It displays relevant messages and provides settings options. It also explains how to use ChassistantGPT and highlights its privacy policy. |
-| [VoiceDropdown.jsx](https://github.com/idosal/assistant-chat-gpt/blob/main/src/components/VoiceDropdown.jsx) | This code snippet is a React component that renders a voice selection dropdown menu. It uses the Web Speech API to get available voices and updates the dropdown options accordingly. When a voice is selected, it updates the state and sends the selected voice to a background script. It also includes a button to test the selected voice. |
-| [Settings.jsx](https://github.com/idosal/assistant-chat-gpt/blob/main/src/components/Settings.jsx) | The code snippet defines a Settings component that manages a toggle switch for enabling/disabling filler in a voice conversation. It uses the useState hook to track the state of the toggle switch and onChange event to update the state and trigger an action. The component renders a Toggle component from the react-toggle library along with a label. |
+| File | Summary |
+| --- | --- |
+| [TriggerInput.jsx](https://github.com/idosal/assistant-chat-gpt/blob/main/src/components/TriggerInput.jsx) | This code is a React component called VoiceDropdown that renders an input field for the user to set a trigger phrase. The trigger phrase is stored in a state variable called "trigger" using the useState hook. When the user changes the input value, the handleChange function is called to update the trigger state and also call the setTriggerPhrase function with the updated value. The trigger phrase value is displayed in the input field. |
+| [Popup.jsx](https://github.com/idosal/assistant-chat-gpt/blob/main/src/components/Popup.jsx) | This code is a React component that renders a chat interface. It uses the Chat UI Kit React library to display a list of messages. The component fetches message history from a background script in a Chrome extension and updates the UI in real-time. It also includes a scroll-to-bottom feature when new messages are received. The code provides a user-friendly chat experience with a ChatGPT assistant. |
+| [Callout.jsx](https://github.com/idosal/assistant-chat-gpt/blob/main/src/components/Callout.jsx) | The code exports a React component called Callout. It takes in two props: "type" and "children". It returns a div element with a className of "callout" followed by the "type" prop value. The content of the callout is rendered within the div element. |
+| [Info.jsx](https://github.com/idosal/assistant-chat-gpt/blob/main/src/components/Info.jsx) | This code is a React component that represents the user interface for a voice assistant called "ChassistantGPT". It includes features such as microphone access, browser compatibility check, settings configuration, and instructions on how to use the assistant. The component also provides information about the privacy aspects of the assistant. Overall, it creates a user-friendly interface for interacting with the voice assistant. |
+| [VoiceDropdown.jsx](https://github.com/idosal/assistant-chat-gpt/blob/main/src/components/VoiceDropdown.jsx) | This code is a React component called VoiceDropdown. It fetches a list of available voices from the browser's speech synthesis API, displays them in a dropdown menu, and allows the user to select a voice. The selected voice is then sent to another function in the same module that sets it as the active voice. There is also a button to test the selected voice by playing a sample audio. |
+| [Settings.jsx](https://github.com/idosal/assistant-chat-gpt/blob/main/src/components/Settings.jsx) | The code is a React component that renders a toggle switch for enabling or disabling a feature called "Filler" in a settings menu. When the toggle is changed, it updates the state and calls a function to set the "FillerEnabled" value. |
Root
-| File | Summary |
-| --- | --- |
-| [build.gradle](https://github.com/rumaan/file.io-Android-Client/blob/main/build.gradle) | This code snippet configures the build dependencies for an Android project. It includes dependencies for the Android Gradle plugin, Fabric, Google Services, and Kotlin. It also sets up the repositories to resolve these dependencies. |
-| [settings.gradle](https://github.com/rumaan/file.io-Android-Client/blob/main/settings.gradle) | The provided code snippet includes the':app' module, which typically represents the main application module in an Android project. It encapsulates the core functionalities of the application, including user interface, data handling, and various features. |
+| File | Summary |
+| --- | --- |
+| [build.gradle](https://github.com/rumaan/file.io-Android-Client/blob/main/build.gradle) | This code sets up the necessary dependencies for building an Android project. It includes libraries for Android tools, Fabric, Google Play Services, and Kotlin. It also configures the repositories for fetching these dependencies. |
+| [settings.gradle](https://github.com/rumaan/file.io-Android-Client/blob/main/settings.gradle) | The code focuses on the app module, which contains the core functionalities of the application. It is responsible for managing the overall behavior and features of the app. |
+| [.travis.yml](https://github.com/rumaan/file.io-Android-Client/blob/main/.travis.yml) | This code is for an Android project. It sets up the required JDK, Android SDK, and licenses. It also handles cache management for Gradle and Android build processes. |
+
+Screenshots
+
+| File | Summary |
+| --- | --- |
+| [readme.txt](https://github.com/rumaan/file.io-Android-Client/blob/main/screenshots/readme.txt) | The code provides a user interface for managing todos. The readme.txt contains instructions on how to use the code. The screenshot.png displays the visual design of the user interface. The todo-ui.png shows an example of how the user interface should appear when managing todos. |
App
-| File | Summary |
-| --- | --- |
-| [build.gradle](https://github.com/rumaan/file.io-Android-Client/blob/main/app/build.gradle) | The provided code snippet is a configuration file for an Android application. It includes plugins for Android development, Kotlin language support, and Fabric Crashlytics reporting. It sets up various dependencies for library and test handling, such as AppCompat, ConstraintLayout, Material Design, Room, Fuel, Gson, and Timber. It also integrates Firebase Crashlytics and Google Services. |
+| File | Summary |
+| --- | --- |
+| [build.gradle](https://github.com/rumaan/file.io-Android-Client/blob/main/app/build.gradle) | This code is for an Android application and includes various plugins and dependencies for different functionalities. It sets up the build configurations, defines dependencies for UI components, testing frameworks, libraries, and services like Firebase Crashlytics and Google services. It also includes permissions handling, data persistence using Room, and navigation using the Android Navigation component. Overall, it's a comprehensive setup for developing an Android app with various features. |
Fileio
-| File | Summary |
-| --- | --- |
-| [ExampleInstrumentedTest.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/androidTest/java/com/thecoolguy/rumaan/fileio/ExampleInstrumentedTest.kt) | This code snippet is a test class for an Android application. It uses instrumentation testing to verify that the app's context matches the expected package name. The test is run on an Android device using the AndroidJUnit4 test runner. |
-| [FileEntityDaoTest.java](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/androidTest/java/com/thecoolguy/rumaan/fileio/FileEntityDaoTest.java) | The provided code snippet is a JUnit test class for testing the functionalities of a Room Database. It includes tests to verify the insertion of items into the database, the counting of rows in the database, and retrieving multiple items from the database. |
-| [UploadHistoryInstrumentedTest.java](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/androidTest/java/com/thecoolguy/rumaan/fileio/UploadHistoryInstrumentedTest.java) | This code snippet is an instrumented test for the UploadHistoryActivity class. It sets up a Room database, adds five items to the database, and has a test method to check the functionality of long-pressing and deleting an item in the activity. |
-| [ExampleUnitTest.java](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/test/java/com/thecoolguy/rumaan/fileio/ExampleUnitTest.java) | The provided code snippet contains a unit test class called "ExampleUnitTest". It includes a single test method called "addition_isCorrect" that asserts whether the sum of 2 and 2 is equal to 4. The goal is to ensure that the addition operation is correct. |
-| [UploadRepositoryTest.java](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/test/java/com/thecoolguy/rumaan/fileio/UploadRepositoryTest.java) | The provided code snippet is a unit test for the check_ExpireUrl function in the UploadRepository class. It tests whether the generated expire URL matches the expected URL with the provided days value and the URL with predefined constants. |
-| [UrlTest.java](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/test/java/com/thecoolguy/rumaan/fileio/UrlTest.java) | The code snippet tests the functionality of a URL parser that is part of a file input/output package. It verifies if a given encrypted URL can be parsed correctly to obtain the base URL. |
-| [FileEntityTest.java](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/test/java/com/thecoolguy/rumaan/fileio/FileEntityTest.java) | This code snippet is a unit test for the FileEntity class. It checks if the fileEntity object can correctly set and retrieve a name and URL property. |
+| File | Summary |
+| --- | --- |
+| [ExampleInstrumentedTest.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/androidTest/java/com/thecoolguy/rumaan/fileio/ExampleInstrumentedTest.kt) | This code is an instrumented test for an Android app. It checks if the app's package name is correct and verifies the context of the app under test. |
+| [FileEntityDaoTest.java](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/androidTest/java/com/thecoolguy/rumaan/fileio/FileEntityDaoTest.java) | This code contains test cases for a RoomDatabase implementation to perform CRUD operations on FileEntity objects. It includes tests to check the count of rows, save and retrieve single items, and save and retrieve multiple items. |
+| [UploadHistoryInstrumentedTest.java](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/androidTest/java/com/thecoolguy/rumaan/fileio/UploadHistoryInstrumentedTest.java) | The code is an instrumented test for an UploadHistoryActivity in an Android app. It creates a Room database and adds five items to it. The test method is yet to be implemented. |
+| [ExampleUnitTest.java](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/test/java/com/thecoolguy/rumaan/fileio/ExampleUnitTest.java) | This code is an example unit test that checks if the addition of 2 + 2 equals 4. |
+| [UploadRepositoryTest.java](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/test/java/com/thecoolguy/rumaan/fileio/UploadRepositoryTest.java) | The code tests the functionality of the UploadRepository class by checking if the generated expire URL matches the expected URL. It verifies that the URL is created correctly by comparing it with a manually constructed URL using constants. |
+| [UrlTest.java](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/test/java/com/thecoolguy/rumaan/fileio/UrlTest.java) | This code is a unit test for the URLParser class. It tests the functionality of the parseEncryptUrl method by comparing the expected result with the actual result. |
+| [FileEntityTest.java](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/test/java/com/thecoolguy/rumaan/fileio/FileEntityTest.java) | The code is a unit test case for the FileEntity class. It verifies that the FileEntity object correctly sets and retrieves the name and URL properties. |
Viewmodel
-| File | Summary |
-| --- | --- |
-| [UploadHistoryViewModel.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/viewmodel/UploadHistoryViewModel.kt) | This code snippet defines a ViewModel class named UploadHistoryViewModel that extends AndroidViewModel. It provides a LiveData object called uploadList, which contains a list of FileEntity objects retrieved from a Room database. The uploads are fetched and stored in uploadList when the ViewModel is initialized. |
+| File | Summary |
+| --- | --- |
+| [UploadHistoryViewModel.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/viewmodel/UploadHistoryViewModel.kt) | This code defines a ViewModel class called UploadHistoryViewModel that is responsible for managing the list of uploaded files. It initializes a LiveData object that holds a list of FileEntity objects retrieved from a local database. |
Ui
-| File | Summary |
-| --- | --- |
-| [FileioApplication.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/FileioApplication.kt) | The provided code snippet is responsible for configuring the application and setting up necessary components such as Timber for logging and a custom activity for handling crashes. It extends the Application class and sets up Timber to log debug messages. It also sets up a custom error activity to handle crashes. |
-| [UploadHistoryListAdapter.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/UploadHistoryListAdapter.kt) | This code snippet defines a custom RecyclerView adapter called UploadHistoryListAdapter. It is used for displaying a list of uploaded files with their corresponding dates.The adapter handles different view types for displaying the dates and file items. It also provides methods for updating and manipulating the list of files. |
-| [SwipeToDeleteCallBack.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/SwipeToDeleteCallBack.kt) | The code snippet provides a SwipeToDeleteCallBack class that enables swipe-to-delete functionality in a RecyclerView. It draws a red background and a delete icon when the item is swiped, allowing the user to delete the item by swiping. The class also handles disabling swipes for specific view types. |
-| [NotificationHelper.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/NotificationHelper.kt) | This code snippet defines a NotificationHelper class that is responsible for creating and showing a notification for a successful file upload. It sets the notification's content and appearance, sets an intent for when the notification is clicked, creates a notification channel for devices running Android O and above, and finally displays the notification. |
+| File | Summary |
+| --- | --- |
+| [FileioApplication.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/FileioApplication.kt) | The code is for a custom Android application class called FileioApplication. It initializes logging using Timber and sets up a custom activity for handling crashes using CaocConfig. |
+| [UploadHistoryListAdapter.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/UploadHistoryListAdapter.kt) | The `UploadHistoryListAdapter` class is responsible for managing the data and views in a RecyclerView. It takes a list of `FileEntity` objects and displays them in a list. It also handles different view types for displaying date headers and file items. It provides methods to update the data and perform actions like copying file URLs to the clipboard and removing items. |
+| [SwipeToDeleteCallBack.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/SwipeToDeleteCallBack.kt) | The code provides a SwipeToDelete functionality for a RecyclerView in an Android app. It uses ItemTouchHelper to handle swiping actions and provides a red delete background with a delete icon. It also disables swiping for specific view types. |
+| [NotificationHelper.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/NotificationHelper.kt) | The code defines a NotificationHelper class that creates and displays a notification when a file upload is successful. It uses a NotificationCompat.Builder to configure the notification's appearance and behavior. It also creates a notification channel for devices running Android Oreo and above. The notification includes a pending intent that opens the UploadHistoryActivity when clicked. |
Fragments
-| File | Summary |
-| --- | --- |
-| [NoNetworkDialogFragment.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/fragments/NoNetworkDialogFragment.kt) | This code snippet defines a DialogFragment class called NoNetworkDialogFragment. It creates a dialog with a layout, listens for button clicks, and provides a callback to the parent activity using a DialogClickListener. |
-| [HomeFragment.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/fragments/HomeFragment.kt) | This code snippet represents a fragment in an Android app. It provides a button that triggers a callback to upload a chosen file. The fragment communicates with the activity using a listener interface. It also handles the creation and setup of the fragment's view. |
-| [ResultFragment.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/fragments/ResultFragment.kt) | The given code snippet is for a ResultFragment class in an Android application. It displays a URL and the number of days until it expires. It also provides a button to notify the listener that the task is done. Additionally, it allows the user to copy the URL to their clipboard by clicking on it. |
+| File | Summary |
+| --- | --- |
+| [NoNetworkDialogFragment.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/fragments/NoNetworkDialogFragment.kt) | The code is a DialogFragment implementation in Android that displays a dialog to notify the user when there is no network connection. It creates a custom dialog layout and handles the click event for the "OK" button. The dialog fragment communicates with the activity using a listener interface. |
+| [HomeFragment.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/fragments/HomeFragment.kt) | The HomeFragment class defines a fragment that displays a layout with a button. When the button is clicked, it calls a callback function to notify the listener. The fragment also handles attaching and detaching the listener from the activity. It is part of a larger codebase and can be instantiated using the newInstance() method. |
+| [ResultFragment.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/fragments/ResultFragment.kt) | The ResultFragment class is responsible for displaying the result of a file operation. It receives data (url and days) through newInstance method and updates the UI accordingly. It also supports copying the link to the clipboard and notifying the parent activity when the user is done with the result. |
Activities
-| File | Summary |
-| --- | --- |
-| [MainActivity.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/activities/MainActivity.kt) | The provided code snippet is for the MainActivity class in an Android application. It handles the main functionality of the app, including setting up the toolbar, handling menu options, fragment initialization, file selection, and uploading files using WorkManager. |
-| [ErrorActivity.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/activities/ErrorActivity.kt) | This code snippet defines an ErrorActivity class, which is an activity that is displayed in case of runtime crashes. It sets the layout for the activity and handles the back button event by finishing all activities in the app. |
-| [UploadHistoryActivity.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/activities/UploadHistoryActivity.kt) | This code snippet represents an activity in an Android app called UploadHistoryActivity. It includes functionalities such as creating options menu, handling menu clicks, clearing history, removing history items, animating and displaying a list of upload history items. It also supports swipe-to-delete functionality for the list items. |
-| [AboutActivity.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/activities/AboutActivity.kt) | This code snippet represents an AboutActivity class in an Android app. It extends AppCompatActivity and includes functionalities such as creating a menu, setting a theme, displaying a toolbar, and handling menu item selection to start a new activity. The menu item "menu_open_source" opens the LicenseActivity. |
-| [LicenseActivity.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/activities/LicenseActivity.kt) | The provided code snippet is for a LicenseActivity class that extends MaterialAboutActivity. It overrides two methods to set the activity title and create a MaterialAboutList. The MaterialAboutList contains a list of license cards for different open-source libraries, each card displaying the library name, year, author, and license type. The list is returned by the getMaterialAboutList() method and used to populate the license information in the activity. |
+| File | Summary |
+| --- | --- |
+| [MainActivity.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/activities/MainActivity.kt) | The code represents the main activity of an Android application. It includes functionalities such as handling menu options, uploading files, showing upload progress, and displaying the result. It also handles permissions related to file storage and network connectivity. |
+| [ErrorActivity.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/activities/ErrorActivity.kt) | This code defines an ErrorActivity that is displayed when runtime crashes occur. It extends AppCompatActivity and overrides the onBackPressed() method to finish the activity stack. It sets the activity layout using the setContentView() method. |
+| [UploadHistoryActivity.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/activities/UploadHistoryActivity.kt) | This code represents an activity in an Android app that displays a list of upload history. It provides functionality to clear the history, remove individual items, and handle swipe gestures to delete items. It uses ViewModel and RecyclerView components for data management and UI rendering. |
+| [AboutActivity.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/activities/AboutActivity.kt) | This code is for the AboutActivity, which is an activity in an Android app. It sets a transparent navigation bar, inflates the menu, and handles menu item clicks. It launches the LicenseActivity when the "Open Source" menu item is clicked. |
+| [LicenseActivity.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/ui/activities/LicenseActivity.kt) | The code defines a LicenseActivity that extends MaterialAboutActivity. It creates a list of open source licenses using ConvenienceBuilder's createLicenseCard method. Each license card includes the icon, title, year, author, and license type. The list is then returned and displayed in the LicenseActivity. |
Repository
-| File | Summary |
-| --- | --- |
-| [UploadHistoryWorkers.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/repository/UploadHistoryWorkers.kt) | The code snippet defines two Workers: ClearHistoryWorker and DeleteSingleItemWorker. ClearHistoryWorker clears all upload history in the database. DeleteSingleItemWorker deletes a specific item from the database based on its ID. |
-| [UploadWorker.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/repository/UploadWorker.kt) | The provided code snippet is an implementation of a Worker class in an Android application. It handles file uploads using the Fuel HTTP library. The code retrieves a file from a Uri, uploads it to the specified endpoint, handles the upload progress, and saves the response data to a local database. It also sends a notification upon completion. |
+| File | Summary |
+| --- | --- |
+| [UploadHistoryWorkers.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/repository/UploadHistoryWorkers.kt) | The code includes two worker classes: "ClearHistoryWorker" and "DeleteSingleItemWorker". "ClearHistoryWorker" clears the entire upload history from the database. "DeleteSingleItemWorker" deletes a specific item from the upload history based on its ID. |
+| [UploadWorker.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/repository/UploadWorker.kt) | The UploadWorker class is responsible for uploading a file to a server using Fuel library. It retrieves the file from the specified URI, uploads it synchronously, and handles the response. It saves the upload details in a local database and displays a notification. |
Utils
-| File | Summary |
-| --- | --- |
-| [Extensions.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/utils/Extensions.kt) | This code snippet provides two extension functions: "toast" and "toggleClickable". The "toast" function displays a short toast message on the screen using the provided context. The "toggleClickable" function allows to enable or disable the clickability of a given view by setting its "isClickable" property. |
-| [WorkManagerHelper.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/utils/WorkManagerHelper.kt) | The code snippet provides a function, createUploadWork, that creates and configures a one-time work request for uploading a file. It sets the required network type as connected and passes the file URI as input data to the UploadWorker class. The work request is also tagged for easier identification. |
-| [Utils.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/utils/Utils.kt) | The provided code snippet is a collection of utility methods. It includes functions for retrieving file details, opening file streams, checking network connectivity, displaying dialogs, copying text to clipboard, parsing URLs, parsing JSON, and handling dates. |
-| [Helpers.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/utils/Helpers.kt) | This code snippet includes functions to retrieve and process file metadata, retrieve the file, and compose the file's information into a FileEntity object. |
-| [FragmentHelperExtensions.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/utils/FragmentHelperExtensions.kt) | This code snippet provides extension functions for adding and replacing fragments in the Android FragmentManager. The addFragment function adds a fragment to a specified container with an optional tag, while the replaceFragment function replaces an existing fragment in the container with a new fragment. Both functions handle backstack management and define fragment transitions. |
-| [MaterialIn.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/utils/MaterialIn.kt) | The provided code snippet is a utility class for animating views in an Android app using material design transitions, specifically for the "material in" effect. It animates the views with fade and slide animations based on the specified delay and slide directions. |
-| [Constants.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/utils/Constants.kt) | This code snippet defines global constants for a fileio utility package. It includes base URLs, expiration parameters, default values, and timestamp formats. It also provides URLs for the developer's GitHub and Twitter profiles, as well as an email address. |
+| File | Summary |
+| --- | --- |
+| [Extensions.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/utils/Extensions.kt) | This code provides two extension functions-"toast" and "toggleClickable". The "toast" function displays a short Toast message using a given context. The "toggleClickable" function enables or disables the clickability of a given View. These functions enhance code readability and simplify usage for common tasks in Android development. |
+| [WorkManagerHelper.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/utils/WorkManagerHelper.kt) | The code defines a utility function to create a one-time work request for uploading a file. It sets the required network type constraint and passes the file's URI as input data to the UploadWorker class. |
+| [Utils.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/utils/Utils.kt) | The code provides a collection of helper methods for various functionalities including getting file details, opening files, checking network connectivity, managing dialogs, handling URLs, parsing JSON, and managing dates. It also includes Android-specific utility methods. |
+| [Helpers.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/utils/Helpers.kt) | This code provides functions to extract metadata and retrieve a file from a given Uri. It also includes a function to compose a FileEntity object using a given File and Response. |
+| [FragmentHelperExtensions.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/utils/FragmentHelperExtensions.kt) | This code provides extension functions for adding and replacing fragments in an Android FragmentManager. It simplifies the process by handling transactions, transitions, and back stack management automatically. |
+| [MaterialIn.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/utils/MaterialIn.kt) | The code defines a utility class called MaterialIn that provides functions for animating views. It includes methods for animating views with a material design effect, such as sliding in from a certain direction or fading in. The code handles different gravity directions, delays, and slide offsets to create smooth animations. |
+| [Constants.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/utils/Constants.kt) | This code contains global constants and URI endpoints for a file.io file sharing application. It includes the base URL, expiration parameters, default expiration time, and URLs for GitHub and Twitter profiles. It also includes constants for appending to links, a time stamp format, and an email address. |
Listeners
-| File | Summary |
-| --- | --- |
-| [DialogClickListener.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/listeners/DialogClickListener.kt) | This code snippet defines an interface called `DialogClickListener` that has one method `onDialogPositiveClick`. This method takes in a `Dialog` object and a `Fragment` object as parameters. It is intended to be used as a listener for positive button click events in dialogs. |
-| [OnFragmentInteractionListener.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/listeners/OnFragmentInteractionListener.kt) | The provided code snippet defines an interface "OnFragmentInteractionListener" that contains two functions: "onUploadFileClick()" and "onDone()". This interface serves as a listener for fragment interactions, allowing for the handling of events related to uploading files and completion of actions. |
+| File | Summary |
+| --- | --- |
+| [DialogClickListener.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/listeners/DialogClickListener.kt) | This code defines an interface called DialogClickListener, which contains a method called onDialogPositiveClick. This method takes a Dialog object and a Fragment object as parameters. It is intended to be implemented by classes that need to listen for positive button clicks in dialogs. |
+| [OnFragmentInteractionListener.kt](https://github.com/rumaan/file.io-Android-Client/blob/main/app/src/main/java/com/thecoolguy/rumaan/fileio/listeners/OnFragmentInteractionListener.kt) | This code defines an interface called "OnFragmentInteractionListener" with two functions: "onUploadFileClick()" and "onDone()". These functions are designed to be implemented by other classes to handle events when a file upload button is clicked or when an action is completed. |
Root
-| File | Summary |
-| --- | --- |
-| [Dockerfile](https://github.com/GokuMohandas/mlops-course/blob/main/Dockerfile) | The given code snippet builds a Docker container with a Python 3.7-slim base image. It installs dependencies, copies necessary files, pulls assets from S3 using DVC, and exposed port 8000. Finally, it starts the app using Gunicorn as the server with UvicornWorker and the specified configuration. |
-| [Makefile](https://github.com/GokuMohandas/mlops-course/blob/main/Makefile) | The code snippet is a Makefile script that provides several commands:-"venv" to create a virtual environment and set it up with necessary dependencies.-"style" to execute code styling and formatting.-"clean" to remove unnecessary files.-"test" to run tests on code, data, and models. |
-| [setup.py](https://github.com/GokuMohandas/mlops-course/blob/main/setup.py) | This code snippet is a setup script for a Python package. It loads packages from a requirements.txt file, defines the package details (name, version, description), and specifies package dependencies. It also includes optional extra requirements for different development scenarios (e.g., documentation, testing). |
-
-Streamlit
-
-| File | Summary |
-| --- | --- |
-| [app.py](https://github.com/GokuMohandas/mlops-course/blob/main/streamlit/app.py) | This code snippet uses the Streamlit library to create a web application. It loads and displays data from a CSV file, shows performance metrics, and allows users to input text for prediction using a pre-trained model. |
+| File | Summary |
+| --- | --- |
+| [mkdocs.yml](https://github.com/GokuMohandas/mlops-course/blob/main/mkdocs.yml) | This code defines the core functionalities of a website called "Made With ML." It includes navigation links, a theme, plugins, and a watch feature to reload the documentation for any file changes. The website provides resources related to machine learning, including data, models, training, tuning, evaluation, prediction, serving, and utilities. The code is hosted on GitHub. |
+| [requirements.txt](https://github.com/GokuMohandas/mlops-course/blob/main/requirements.txt) | This code includes a variety of dependencies for different purposes:-Default: Core libraries and frameworks for machine learning, natural language processing, and data analysis.-Notebook: Additional libraries for interactive notebooks and data visualization.-Documentation: Tools for generating documentation for the codebase.-Styling: Libraries for code formatting and style enforcement.-Testing: Libraries for testing and asserting expectations.-Development: Libraries for web development and command-line interface.-Deployment: Libraries for deploying code on distributed systems. |
+| [Makefile](https://github.com/GokuMohandas/mlops-course/blob/main/Makefile) | The code is a Makefile that provides commands for code styling and cleaning. The "style" command formats the code using black, checks for linting errors with flake8, sorts imports with isort, and upgrades code with pyupgrade. The "clean" command removes unnecessary files and directories. |
+| [pyproject.toml](https://github.com/GokuMohandas/mlops-course/blob/main/pyproject.toml) | The code includes configurations for formatting (black), import sorting (isort), linting (flake8), upgrading to Python 3.9+ compatibility (pyupgrade), and test coverage (pytest cov). It aims to ensure code consistency, readability, and quality. |
App
+Deploy
-| File | Summary |
-| --- | --- |
-| [api.py](https://github.com/GokuMohandas/mlops-course/blob/main/app/api.py) | The provided code snippet is a FastAPI web application that provides several endpoints. It allows users to check the health of the application, get performance metrics, retrieve run arguments, and make predictions using a machine learning model. The code defines helper functions for constructing JSON responses and loads necessary artifacts on application startup. |
-| [gunicorn.py](https://github.com/GokuMohandas/mlops-course/blob/main/app/gunicorn.py) | The provided code snippet is a Gunicorn configuration file. It defines various options such as server socket, worker processes, server mechanics, logging, process naming, and server hooks. These options control the behavior and settings of Gunicorn, an HTTP server for running Python web applications. |
-| [schemas.py](https://github.com/GokuMohandas/mlops-course/blob/main/app/schemas.py) | The provided code defines two Pydantic models, "Text" and "PredictPayload", for handling input data. The "Text" model represents a single text and includes validation for a non-empty string. The "PredictPayload" model represents a list of "Text" objects and includes validation for a non-empty list. Each model also includes example data and extra configuration for documentation purposes. |
-| [data.py](https://github.com/GokuMohandas/mlops-course/blob/main/app/data.py) | This code snippet provides several functions for preprocessing and encoding data. It includes functions for replacing out of scope labels and minority labels, cleaning text, and generating data splits. It also includes a LabelEncoder class for encoding labels into unique indices. |
+| File | Summary |
+| --- | --- |
+| [cluster_env.yaml](https://github.com/GokuMohandas/mlops-course/blob/main/deploy/cluster_env.yaml) | This code snippet sets up a Docker environment with a specific base image and necessary dependencies. It installs Python packages, updates pip and installs packages specified in a requirements.txt file. |
+| [cluster_compute.yaml](https://github.com/GokuMohandas/mlops-course/blob/main/deploy/cluster_compute.yaml) | The code defines the core functionalities for deploying a cluster on the AWS cloud. It specifies the region, instance types for head and worker nodes, and other AWS configurations like block device mappings and tags. |
Config
+Jobs
-| File | Summary |
-| --- | --- |
-| [config.py](https://github.com/GokuMohandas/mlops-course/blob/main/config/config.py) | The provided code snippet sets up the necessary directories and logging configuration for a machine learning project. It also initializes the MLFlow model registry and defines a list of stopwords. Overall, the code organizes the project structure and sets up logging for tracking and debugging purposes. |
+| File | Summary |
+| --- | --- |
+| [workloads.yaml](https://github.com/GokuMohandas/mlops-course/blob/main/deploy/jobs/workloads.yaml) | The code defines a set of workloads to be executed on a specified cluster. It includes project details, cluster environment, compute configuration, runtime environment, and the entry point script. It also specifies the maximum number of retries for the workloads. |
+| [workloads.sh](https://github.com/GokuMohandas/mlops-course/blob/main/deploy/jobs/workloads.sh) | This code performs a series of tasks including testing data and code, training a model, evaluating the model, testing the trained model, and saving the model and results to S3. |
Tagifai
+Services
-| File | Summary |
-| --- | --- |
-| [predict.py](https://github.com/GokuMohandas/mlops-course/blob/main/tagifai/predict.py) | The code provides two functions: "custom_predict" and "predict". "custom_predict" takes predicted probabilities and a threshold value, and returns predicted label indices based on conditions. "predict" uses the "custom_predict" function to make predictions for a list of input texts using a set of artifacts. The function transforms the texts using a vectorizer, predicts probabilities using a model, applies the custom predict function, and then decodes the predicted labels. Finally, it returns a list of dictionaries containing predictions for each input text. |
-| [utils.py](https://github.com/GokuMohandas/mlops-course/blob/main/tagifai/utils.py) | This code snippet provides functions to load and save dictionaries from/to JSON files, as well as a function to set a seed for reproducibility in random number generation. The code uses the json library to handle JSON data and the numpy library to set a seed value. |
-| [train.py](https://github.com/GokuMohandas/mlops-course/blob/main/tagifai/train.py) | This code snippet implements the functionality to train a text classification model using the SGD classifier and perform hyperparameter optimization using Optuna. It preprocesses the data, applies TF-IDF vectorization, oversamples the training data, trains the model, and evaluates its performance. The objective of the optimization trial is to maximize the F1 score of the model. |
-| [evaluate.py](https://github.com/GokuMohandas/mlops-course/blob/main/tagifai/evaluate.py) | This code snippet provides functionality for generating performance metrics for classification models. It includes slicing functions for generating metrics on specific slices of data (e.g., projects with NLP and CNN), and overall and per-class metrics. Additionally, it supports generating slice metrics using a Pandas DataFrame. The code promotes modularity and extensibility by using functions and parameterization. |
-| [main.py](https://github.com/GokuMohandas/mlops-course/blob/main/tagifai/main.py) | This code snippet represents a Python CLI application that extracts, transforms, and loads data, trains a machine learning model, optimizes hyperparameters, and makes predictions. It integrates with MLflow for experiment tracking and artifact management. |
-| [data.py](https://github.com/GokuMohandas/mlops-course/blob/main/tagifai/data.py) | The provided code snippet includes functions to preprocess text data, replace out of scope (OOS) and minority labels, and perform label encoding. It also includes a function to generate balanced data splits for training, validation, and testing. The code follows best practices for modularization and includes type hints for better code readability. |
+| File | Summary |
+| --- | --- |
+| [serve_model.yaml](https://github.com/GokuMohandas/mlops-course/blob/main/deploy/services/serve_model.yaml) | HTTPStatus Exception: 503 |
+| [serve_model.py](https://github.com/GokuMohandas/mlops-course/blob/main/deploy/services/serve_model.py) | The code imports necessary modules, copies files from S3, and sets an entrypoint for model deployment based on given parameters. |
Airflow
+Madewithml
-| File | Summary |
-| --- | --- |
-| [webserver_config.py](https://github.com/GokuMohandas/mlops-course/blob/main/airflow/webserver_config.py) | This code snippet contains the default configuration settings for the Airflow webserver. It includes authentication configuration options, such as the authentication type and authentication providers like database, LDAP, and OAuth. It also includes settings for user self-registration, recaptcha, email configuration, and themes for the web interface. |
+| File | Summary |
+| --- | --- |
+| [config.py](https://github.com/GokuMohandas/mlops-course/blob/main/madewithml/config.py) | This code provides the core functionalities for configuration and logging in a Python project. It sets up directories, configures MLflow, initializes logging, and defines a list of stopwords. The logging configuration includes console and file handlers for different log levels. |
+| [models.py](https://github.com/GokuMohandas/mlops-course/blob/main/madewithml/models.py) | This code defines a PyTorch model for fine-tuning a Large Language Model (LLM). The model takes input sequences and masks, passes them through the LLM, applies dropout regularization, and then passes the pooled output through a linear layer to obtain the final predictions. |
+| [predict.py](https://github.com/GokuMohandas/mlops-course/blob/main/madewithml/predict.py) | This code provides functionalities for predicting tags based on input data using a pre-trained model. It includes methods for decoding indices to labels, formatting probabilities, and making predictions with probabilities. It also includes functions for retrieving the best run ID and best checkpoint from an MLflow experiment. The main predict() function takes a specific run ID, project title, and description as inputs and returns the prediction results for the input data. |
+| [serve.py](https://github.com/GokuMohandas/mlops-course/blob/main/madewithml/serve.py) | This code defines a FastAPI application for serving a machine learning model. It includes routes for health check, evaluation, and prediction. The model is loaded using a run ID and a threshold is applied to classify predictions. Ray is used for distributed serving. |
+| [utils.py](https://github.com/GokuMohandas/mlops-course/blob/main/madewithml/utils.py) | This code includes functions for setting seeds, loading and saving dictionaries as JSON files, padding arrays, converting batches of numpy arrays to tensors, retrieving MLflow run IDs, and converting dictionaries to a list of dictionaries. |
+| [tune.py](https://github.com/GokuMohandas/mlops-course/blob/main/madewithml/tune.py) | This code defines a command-line interface (CLI) app for hyperparameter tuning experiments using Ray and Tune. It sets up the necessary configurations, datasets, trainers, and search algorithms for hyperparameter optimization. The results of the tuning experiment are logged using MLflow and saved to a file if specified. The code also includes a main function to initialize Ray and run the CLI app. |
+| [train.py](https://github.com/GokuMohandas/mlops-course/blob/main/madewithml/train.py) | This code defines a distributed training workload using Ray, Torch, and Transformers for training a language model.The code implements functions for training and evaluating the model, as well as a distributed training loop.It also includes CLI options for configuring the training workload.The code uses MLflow for logging and checkpointing, and supports distributed training with multiple workers and GPUs. |
+| [evaluate.py](https://github.com/GokuMohandas/mlops-course/blob/main/madewithml/evaluate.py) | This code includes functions for evaluating the performance of a model on a dataset. It calculates overall metrics, per class metrics, and metrics for different slices of the data. The evaluation results can be saved to a file if specified. |
+| [data.py](https://github.com/GokuMohandas/mlops-course/blob/main/madewithml/data.py) | This code contains several core functionalities. It includes functions for loading data into a Ray Dataset, stratified splitting of datasets, text cleaning, tokenization using a pre-trained BERT tokenizer, and data preprocessing. There is also a custom preprocessor class that fits and transforms the data. |
Dags
+Workflows
-| File | Summary |
-| --- | --- |
-| [workflows.py](https://github.com/GokuMohandas/mlops-course/blob/main/airflow/dags/workflows.py) | This code snippet creates a DAG (Directed Acyclic Graph) in Airflow for MLOps tasks. It connects to a BigQuery data warehouse, extracts labeled data, validates it using Great Expectations, optimizes a model, and trains the model. |
+| File | Summary |
+| --- | --- |
+| [serve.yaml](https://github.com/GokuMohandas/mlops-course/blob/main/.github/workflows/serve.yaml) | The code sets up AWS credentials, installs dependencies, and serves a machine learning model using AnyScale. |
+| [json_to_md.py](https://github.com/GokuMohandas/mlops-course/blob/main/.github/workflows/json_to_md.py) | This code converts a JSON file to a formatted markdown file. It reads the JSON data, converts it to markdown format, and saves it to a file. The `to_markdown` function handles the conversion, and the `json_to_markdown` function orchestrates the process. The code also includes command-line argument handling. |
+| [workloads.yaml](https://github.com/GokuMohandas/mlops-course/blob/main/.github/workflows/workloads.yaml) | The code sets up AWS credentials, installs dependencies, runs workloads, reads results from S3, and comments them on a pull request. |
+| [documentation.yaml](https://github.com/GokuMohandas/mlops-course/blob/main/.github/workflows/documentation.yaml) | The code is a GitHub Actions workflow that builds and deploys documentation using MkDocs. It sets up Python dependencies, installs MkDocs and mkdocstrings, and then deploys the documentation using the "mkdocs gh-deploy" command. |
Notebooks
-| File | Summary |
-| --- | --- |
-| [tagifai.ipynb](https://github.com/GokuMohandas/mlops-course/blob/main/notebooks/tagifai.ipynb) | Prompt exceeds max token limit: 214679. |
+| File | Summary |
+| --- | --- |
+| [benchmarks.ipynb](https://github.com/GokuMohandas/mlops-course/blob/main/notebooks/benchmarks.ipynb) | Prompt exceeds max token limit: 4000. |
+| [madewithml.ipynb](https://github.com/GokuMohandas/mlops-course/blob/main/notebooks/madewithml.ipynb) | Prompt exceeds max token limit: 218014. |
-
-flink-flow
+
flink-flow
-
โฆ Flink, flow, conquer code.
+
โฆ Streaming made seamless
โฆ Developed with the software and tools listed below.
@@ -17,23 +15,25 @@ flink-flow
-
-
-
-
-
+
+
+
+
---
-## ๐ Table of Contents
-- [๐ Table of Contents](#-table-of-contents)
+## ๐ Table of Contents
+- [๐ Table of Contents](#-table-of-contents)
- [๐ Overview](#-overview)
-- [โ๏ธ Features](#-features)
-- [๐ Project Structure](#project-structure)
-- [๐งฉ Modules](#modules)
+- [๐ฆ Features](#-features)
+- [๐ Repository Structure](#-repository-structure)
+- [โ๏ธ Modules](#modules)
- [๐ Getting Started](#-getting-started)
-- [๐บ Roadmap](#-roadmap)
+ - [๐ง Installation](#-installation)
+ - [๐ค Running flink-flow](#-running-flink-flow)
+ - [๐งช Tests](#-tests)
+- [๐ฃ Roadmap](#-roadmap)
- [๐ค Contributing](#-contributing)
- [๐ License](#-license)
- [๐ Acknowledgments](#-acknowledgments)
@@ -43,28 +43,29 @@ flink-flow
## ๐ Overview
-The project is focused on creating a data processing pipeline using Apache Flink and Python. It provides functionalities for setting up a Flink cluster, processing data streams, generating alerts for flagged records, and handling alerts through a REST API. Its value proposition lies in enabling efficient real-time data processing, scalable cluster management, and seamless integration with Python for data analysis and alert handling.
+The project is a scalable data stream processing system built on Apache Flink and Python. It enables distributed processing of streaming data using Flink's powerful capabilities and leverages Python's data manipulation and web request functionalities. The system includes a REST API alert handler for sending alerts to external APIs, a logger for efficient logging, and a consumer module for processing and analyzing data streams. The project's value proposition lies in its ability to handle high-throughput data streams, perform complex processing tasks, and provide fault-tolerance and scalability for real-time data analysis.
---
-## โ๏ธ Features
-
-| Feature | Description |
-| ---------------------- | ------------------------------------- |
-| **โ๏ธ Architecture** | The codebase follows a modular architecture, with separate files for different components such as alerts handler, logger, and consumer. It leverages Apache Flink for stream processing and utilizes Python for scripting and data manipulation. The architecture allows for easy scalability and extensibility. |
-| **๐ Documentation** | The codebase lacks comprehensive documentation. There are some comments in the code, but they are limited and do not provide a detailed explanation of the design choices or overall system functionality. Improving the documentation would enhance the codebase's readability and maintainability. |
-| **๐ Dependencies** | The codebase has dependencies on external libraries such as PyFlink, aiohttp, Apache Avro, logging, and colorlog. These libraries provide essential functionality for tasks such as stream processing, API handling, logging, and serialization. The usage of external libraries enhances the capabilities of the system without reinventing the wheel. |
-| **๐งฉ Modularity** | The system demonstrates good modularity, with separate files for different components. This modular approach allows for easier maintenance, testing, and reusability of code. The components can be easily replaced, upgraded, or extended without affecting the entire system. |
-| **โ๏ธ Testing** | The codebase does not have a comprehensive testing strategy. There are no dedicated test files or frameworks in place. This makes it challenging to ensure the correctness and reliability of the system. Implementing unit tests, integration tests, and end-to-end tests would enhance the testing coverage and overall system quality. |
-| **โก๏ธ Performance** | The codebase's performance depends on the underlying technologies used, such as Apache Flink. Apache Flink is known for its high-performance stream processing capabilities. However, without performance benchmarks or optimization techniques specific to the codebase, it is challenging to assess the system's performance accurately. |
-| **๐ Security** | The codebase does not explicitly address security measures. It may be necessary to implement authentication, authorization, and data encryption to protect sensitive information. Without detailed security measures, the system's data and functionality are potentially vulnerable. |
-| **๐ Version Control** | The codebase utilizes Git for version control, as evidenced by its presence on GitHub. However, further exploration of the repository history, branches, and commit messages is needed to gauge the effectiveness of the version control strategy. Regular use of branches and descriptive commit messages is recommended to track changes and collaborate effectively. |
-| **๐ Integrations** | The system interacts with other systems through the REST API alerts handler. This allows seamless integration with external systems, enabling the exchange of data or triggering actions based on alerts. The codebase could benefit from additional integrations with monitoring systems, database connectors, or other APIs to
+## ๐ฆ Features
+
+| Feature | Description |
+| ---------------------- | -------------------------------------------------------------------------------------------------------------------- |
+| **โ๏ธ Architecture** | The codebase follows a distributed stream processing architecture using Apache Flink and Python. It leverages PyFlink, aiohttp, and Avro for efficient and scalable data processing. |
+| **๐ Documentation** | The codebase lacks comprehensive documentation, which could make it challenging for new contributors to understand and use the project effectively. |
+| **๐ Dependencies** | The codebase relies on several external libraries, such as pandas, asyncio, aiohttp, aioresponses, apache-flink, pyflink, and apache-kafka, to enable various functionalities. |
+| **๐งฉ Modularity** | The codebase is organized into separate files, each serving a specific purpose, such as setup, configuration, API handling, logging, data processing, and cleaning tasks. |
+| **๐งช Testing** | The codebase lacks explicit testing strategies and tools, making it difficult to assess the overall code quality and reliability. |
+| **โก๏ธ Performance** | The system's performance is highly dependent on the efficiency and scalability of Apache Flink and PyFlink for distributed stream processing, ensuring high throughput and fault tolerance. |
+| **๐ Security** | The codebase does not explicitly address security measures. However, using well-maintained external libraries like aiohttp and PyFlink can provide some level of security. |
+| **๐ Version Control** | The codebase utilizes Git for version control, allowing for collaborative development, tracking changes, and managing code revisions effectively. |
+| **๐ Integrations** | The system integrates with external services, such as REST APIs and Kafka, for sending alerts and handling high-throughput messaging, respectively. |
+| **๐ถ Scalability** | With Apache Flink and PyFlink, the system can handle high volumes of data and scale horizontally by adding more task managers to the Flink cluster for distributed processing. |
---
-## ๐ Project Structure
+## ๐ Repository Structure
```bash
@@ -92,40 +93,50 @@ repo
---
-## ๐งฉ Modules
+## โ๏ธ Modules
Root
-| File | Summary |
-| --- | --- |
-| [setup.py](https://github.com/eli64s/flink-flow/blob/main/setup.py) | The code snippet is a setup.py file used for packaging a Python project. It collects required packages from a requirements.txt file and defines additional packages for documentation, code style, and testing. It also specifies the project name, version, and dependencies. |
+| File | Summary |
+| --- | --- |
+| [requirements.txt](https://github.com/eli64s/flink-flow/blob/main/requirements.txt) | The code uses pandas for data manipulation, asyncio and aiohttp for asynchronous web requests, aioresponses for mocking HTTP responses, apache-flink and pyflink for distributed stream processing, and apache-kafka for high-throughput messaging. |
+| [setup.py](https://github.com/eli64s/flink-flow/blob/main/setup.py) | This code is a setup script for a Python package. It defines the package name, version, dependencies, and other metadata. It also includes extra requirements for development and testing. |
Setup
-| File | Summary |
-| --- | --- |
-| [setup.sh](https://github.com/eli64s/flink-flow/blob/main/setup/setup.sh) | This code snippet checks for Java 11, Python 3.7, and Conda installations. It then downloads and extracts PyFlink, sets environment variables, and creates aliases for easier usage. Finally, it displays a completion message. |
+| File | Summary |
+| --- | --- |
+| [setup.sh](https://github.com/eli64s/flink-flow/blob/main/setup/setup.sh) | This code is a shell script that automates the setup process for PyFlink, a Python API for Apache Flink. It checks for Java 11 and Python 3.7 installations, installs them if necessary, creates a Conda environment, downloads and extracts PyFlink, sets environment variables, and sets aliases for zsh. |
Scripts
-| File | Summary |
-| --- | --- |
-| [run.sh](https://github.com/eli64s/flink-flow/blob/main/scripts/run.sh) | The code snippet starts a Flink cluster, submits a PyFlink job called "word_count.py", and then stops the Flink cluster. |
-| [clean.sh](https://github.com/eli64s/flink-flow/blob/main/scripts/clean.sh) | This code snippet performs various cleanup operations such as deleting backup files, purging Python cache, removing build artifacts, deleting Jupyter notebook checkpoints, and clearing pytest cache. It also deletes log files. |
+| File | Summary |
+| --- | --- |
+| [run.sh](https://github.com/eli64s/flink-flow/blob/main/scripts/run.sh) | This code script starts a Flink cluster, submits a PyFlink job (word_count.py), and then stops the Flink cluster. |
+| [clean.sh](https://github.com/eli64s/flink-flow/blob/main/scripts/clean.sh) | This script performs a series of cleanup tasks. It deletes backup files, cleans up Python cache files, removes build artifacts, Jupyter notebook checkpoints, pytest cache, and log files. |
+
+Conf
+
+| File | Summary |
+| --- | --- |
+| [flink-config.yaml](https://github.com/eli64s/flink-flow/blob/main/conf/flink-config.yaml) | This code is a Flink configuration file that sets various properties for the Flink job manager, task manager, high availability, parallelism, state backend, and logging. It specifies parameters such as memory size, number of threads, storage directories, quorum, and logging levels. |
+| [conf.toml](https://github.com/eli64s/flink-flow/blob/main/conf/conf.toml) | This code defines configuration constants for connecting to a Kafka server and a Flink job manager. It specifies the bootstrap servers, topic, job manager address, and parallelism for Flink tasks. |
Src
-| File | Summary |
-| --- | --- |
-| [alerts_handler.py](https://github.com/eli64s/flink-flow/blob/main/src/alerts_handler.py) | The code snippet provides a REST API alert handler for the Flink consumer. It allows sending alerts to an API in batches using aiohttp and serializes the alerts using Apache Avro. The code also includes functions to buffer alerts and send them in batches. |
-| [logger.py](https://github.com/eli64s/flink-flow/blob/main/src/logger.py) | The provided code snippet is a Logger class that configures and provides functions to log messages with different severity levels. It uses the Python logging library to create a logger object and sets the log level to DEBUG by default. The logger is configured to output logs to the console with colored formatting using the colorlog library. It provides functions to log messages with different severity levels such as info, debug, warning, error, and critical. Each function passes the log message to the underlying logger object with the corresponding severity level. |
-| [consumer.py](https://github.com/eli64s/flink-flow/blob/main/src/consumer.py) | This code snippet leverages Apache Flink and Python to process a data stream. It sets up the Flink environment, creates tables, performs windowed joins, and generates alerts for flagged records. |
+| File | Summary |
+| --- | --- |
+| [alerts_handler.py](https://github.com/eli64s/flink-flow/blob/main/src/alerts_handler.py) | This code is a REST API alert handler that sends alerts to an external API in batches. It includes functions for buffering alerts, serializing them using Avro, and sending them asynchronously using aiohttp. The code also includes error handling and logging capabilities. |
+| [logger.py](https://github.com/eli64s/flink-flow/blob/main/src/logger.py) | The code defines a Logger class that configures a logging module to provide colorful and formatted log messages. It supports different log levels and logging methods such as info, debug, warning, error, and critical. |
+| [consumer.py](https://github.com/eli64s/flink-flow/blob/main/src/consumer.py) | This code implements data stream processing using Apache Flink and Python. It sets up the Flink execution environment, creates tables, defines processing logic, and handles alerts for flagged records. The stream and batch data are joined, filtered, and processed, with results printed and saved to an output sink. Checkpointing and buffering mechanisms ensure fault-tolerance and efficient processing. |
-
-CallMon
+
CallMon
-
โฆ Tracking calls made easy.
+
โฆ Connect, collaborate, and monitor calls with CallMon
โฆ Developed with the software and tools listed below.
@@ -13,23 +11,25 @@ CallMon
-
-
-
-
-
+
+
+
+
---
-## ๐ Table of Contents
-- [๐ Table of Contents](#-table-of-contents)
+## ๐ Table of Contents
+- [๐ Table of Contents](#-table-of-contents)
- [๐ Overview](#-overview)
-- [โ๏ธ Features](#-features)
-- [๐ Project Structure](#project-structure)
-- [๐งฉ Modules](#modules)
+- [๐ฆ Features](#-features)
+- [๐ Repository Structure](#-repository-structure)
+- [โ๏ธ Modules](#modules)
- [๐ Getting Started](#-getting-started)
-- [๐บ Roadmap](#-roadmap)
+ - [๐ง Installation](#-installation)
+ - [๐ค Running CallMon](#-running-CallMon)
+ - [๐งช Tests](#-tests)
+- [๐ฃ Roadmap](#-roadmap)
- [๐ค Contributing](#-contributing)
- [๐ License](#-license)
- [๐ Acknowledgments](#-acknowledgments)
@@ -39,27 +39,27 @@ CallMon
## ๐ Overview
-The "CallMon" project is a kernel-mode driver and accompanying GUI application that work together to capture and display information about system call events in the Windows operating system. The driver component hooks system call handlers and communicates with the GUI application through a named pipe. The GUI application creates a dialog box and displays information about the processes that make system calls. By providing insights into the system call activities of different processes, the project enables users to monitor and analyze system-level behavior, aiding in debugging and security analysis efforts.
+The project at https://github.com/DownWithUp/CallMon is a Windows driver and GUI application that allows for the monitoring and manipulation of system calls made by processes. It provides functionality to add and remove processes, suspend and resume processes, and register a handler for system calls. The project's value proposition lies in its ability to provide insights and control over system call activity, making it useful for debugging, security analysis, and performance profiling purposes.
---
-## โ๏ธ Features
+## ๐ฆ Features
| Feature | Description |
| ---------------------- | ------------------------------------- |
-| **โ๏ธ Architecture** | The system follows a modular architecture, with separate components for the driver and the GUI application. The driver handles system call monitoring and communicates with the GUI application via IOCTL requests and a named pipe. The GUI application is responsible for creating the GUI dialog and displaying information about system call events. Overall, the architecture promotes separation of concerns and allows for easy maintenance and scalability. |
-| **๐ Documentation** | The codebase lacks comprehensive documentation. While some code files have brief comments, there is no centralized or detailed documentation explaining the purpose, usage, and design choices of the components. Improving the documentation would greatly benefit developers and make the codebase more accessible to new contributors. |
-| **๐ Dependencies** | The system relies on external dependencies such as the Windows API, Rust, and the winapi crate. These dependencies provide access to low-level functionality required for kernel-mode driver development and GUI development. The codebase should be kept updated with the latest versions of these dependencies to ensure compatibility and security. |
-| **๐งฉ Modularity** | The system exhibits a good level of modularity, with clear separation between the driver and GUI components. Functionalities such as process management, syscall monitoring, communication, and GUI rendering are organized into their respective modules. This allows for easy maintenance, testing, and reusability of the codebase. |
-| **โ๏ธ Testing** | The codebase does not include a dedicated testing strategy or testing tools. Adding unit tests for critical components and employing a testing framework such as Rust's `cargo test` would help ensure the correctness and robustness of the system. Additionally, considering automated integration testing between the driver and GUI application would be beneficial. |
-| **โก๏ธ Performance** | Given that the system deals with kernel-mode driver development, it is crucial to prioritize performance. However, without specific performance optimizations mentioned in the codebase, it is challenging to make conclusive remarks. Performance profiling and optimization techniques can be employed to analyze and enhance the system's speed, efficiency, and resource usage. |
-| **๐ Security** | Security measures must be a top concern in the development of a kernel-mode driver. While the codebase handles aspects such as process isolation, access control, and interaction with the Windows API, a comprehensive security analysis of the system could not be obtained solely from code review. Following secure coding practices, code audits, and threat modeling would be essential for ensuring the system's security. |
-| **๐ Version Control** | The codebase utilizes the Git version control system, as evident from its presence on GitHub. However, the analysis of the repository did not provide an indication of specific version control strategies or tools employed. To streamline the development process and facilitate collaboration, teams should make use of branching, tagging, and code
+| **โ๏ธ Architecture** | The system follows a modular architecture, with separate components for the driver, Rust library, and GUI application. The driver allows monitoring and manipulation of system calls, while the Rust library provides integration with the Windows API. The GUI application provides a user-friendly interface for interacting with the driver. Overall, the system follows a layered design pattern, separating the UI, business logic, and system integration. |
+| **๐ Documentation** | The project lacks comprehensive documentation. While individual files have brief descriptions, there is no overarching documentation explaining the project's purpose, usage, or design decisions. This can make it challenging for new contributors or users to understand and navigate the codebase. Improved documentation would enhance the project's accessibility and usability. |
+| **๐ Dependencies** | The system relies on various external libraries and crates, including "winapi," "winreg," "failure," and "obfstr." These dependencies provide integration with the Windows API, error handling functionality, and obfuscation capabilities. The project also utilizes environment variables to configure build paths and flags. Managing these dependencies is crucial to ensure compatibility and stability across different versions. |
+| **๐งฉ Modularity** | The codebase demonstrates good modularity by dividing the functionality into separate files and components. The driver, Rust library, and GUI application each have their own directories and files, encapsulating related functionalities. This modular approach makes the codebase easier to understand, maintain, and test. The use of different files for struct definitions, utility functions, and integration with external systems further enhances modularity. |
+| **๐งช Testing** | The project lacks explicit testing strategies and tools. While the code includes error handling and input validations, there is no evidence of unit tests or automated test suites. Introducing a testing framework, such as Rust's built-in testing framework or a third-party library like `rust-test` or `cargo-test`, would improve code reliability and maintainability. Proper testing is crucial for ensuring the project's correctness and identifying bugs or regressions. |
+| **โก๏ธ Performance** | As a driver-based system, performance is a critical aspect. The project leverages low-level system APIs and optimized Rust code to ensure efficient system call monitoring and manipulation. However, without specific performance benchmarks or profiling data, it is challenging to determine the performance characteristics accurately. To evaluate performance, it would be beneficial to conduct performance testing using realistic workloads and scenarios to identify any bottlenecks or areas for optimization. |
+| **๐ Security** | The system's security measures are not explicitly mentioned in the provided information. However, given that the project involves manipulating system calls and interacting with the Windows API, it's crucial to ensure robust security practices. This includes handling user input securely, preventing privilege escalation, and protecting sensitive information. Conducting security audits, staying updated with security patches, and following secure coding practices are essential to maintain the project's security. |
+| **๐ Version Control** | The project uses Git for version control, with the codebase hosted on GitHub. The GitHub repository includes a complete history of commits, allowing for easy tracking of changes and collaboration among team members. It enables branching for feature development, bug fixes, and experimental work. However, without additional information, it is difficult to assess the specific version control strategies or
---
-## ๐ Project Structure
+## ๐ Repository Structure
```bash
@@ -90,53 +90,56 @@ repo
---
-## ๐งฉ Modules
+## โ๏ธ Modules
Driver
-| File | Summary |
-| --- | --- |
-| [AltCall.c](https://github.com/DownWithUp/CallMon/blob/main/Driver/AltCall.c) | The provided code snippet is a driver implementation that provides functionality for adding and removing processes, as well as hooking system call handlers. It also includes an IOCTL handler for managing communication with a named pipe and a driver entry and unload function for initializing and cleaning up the driver. |
-| [Extras.h](https://github.com/DownWithUp/CallMon/blob/main/Driver/Extras.h) | The code snippet defines structures for a custom packet header and a total packet.The custom header contains a process ID and an array of stack data.The total packet combines the custom header with a KTRAP_FRAME structure. |
+| File | Summary |
+| --- | --- |
+| [AltCall.c](https://github.com/DownWithUp/CallMon/blob/main/Driver/AltCall.c) | The code is a Windows driver that allows monitoring and manipulation of system calls made by processes. It provides functionality to add and remove processes, suspend and resume processes, and register a handler for system calls. It also includes device control functions for communication. |
+| [Extras.h](https://github.com/DownWithUp/CallMon/blob/main/Driver/Extras.h) | The code defines two structures: CUSTOM_HEADER and TOTAL_PACKET. The CUSTOM_HEADER structure contains a process ID and an array of stack data. The TOTAL_PACKET structure combines the CUSTOM_HEADER structure with a KTRAP_FRAME structure. |
Rust
-| File | Summary |
-| --- | --- |
-| [build.rs](https://github.com/DownWithUp/CallMon/blob/main/Rust/build.rs) | The code snippet retrieves the path to Windows Kits directory and the kernel mode libraries. It then determines the appropriate architecture based on the target platform. Finally, it uses the obtained paths to configure the Rust build process for linking. |
+| File | Summary |
+| --- | --- |
+| [Makefile.toml](https://github.com/DownWithUp/CallMon/blob/main/Rust/Makefile.toml) | This code defines a set of tasks for building, renaming, and signing a Windows driver. It uses environment variables for target paths and build flags, and the tasks are executed sequentially with dependencies. The final task signs the driver using a self-signed certificate and a timestamp service. |
+| [Cargo.toml](https://github.com/DownWithUp/CallMon/blob/main/Rust/Cargo.toml) | The code is a Rust package named "AltCall" that contains a library with dynamic linking capabilities. It depends on other crates such as "kernel-print" and "kernel-alloc" for kernel-level operations, and "obfstr" for obfuscation functionality. It also relies on the "winapi" crate for Windows API integration. Additionally, it uses the "winreg" and "failure" crates for building purposes. |
+| [rustfmt.toml](https://github.com/DownWithUp/CallMon/blob/main/Rust/rustfmt.toml) | This code configures various formatting options for the Rust codebase. It sets rules for indentation, line breaks, ordering, and shorthand usage. The aim is to improve code readability and maintain consistency. |
+| [build.rs](https://github.com/DownWithUp/CallMon/blob/main/Rust/build.rs) | The code retrieves the path to the Windows Kits directory and the kernel mode libraries. It then determines the appropriate architecture and sets the link search path for the Rust compiler. |
.cargo
-| File | Summary |
-| --- | --- |
-| [config](https://github.com/DownWithUp/CallMon/blob/main/Rust/.cargo/config) | This code snippet is a configuration file for building a Rust project on Windows. It sets various pre and post link arguments, like disabling certain default libraries, specifying the subsystem and entry point, optimizing code, and maintaining integrity. |
+| File | Summary |
+| --- | --- |
+| [config](https://github.com/DownWithUp/CallMon/blob/main/Rust/.cargo/config) | This code sets specific build configurations for a Rust project targeting Windows. It includes pre-link and post-link arguments, specifying various options for optimization, linking, and subsystems. The code aims to optimize and configure the executable for a native Windows environment. |
Src
-| File | Summary |
-| --- | --- |
-| [externs.rs](https://github.com/DownWithUp/CallMon/blob/main/Rust/src/externs.rs) | This code snippet imports a set of functions from Windows API libraries and defines some types. These functions provide functionalities such as creating devices, creating symbolic links, suspending and resuming processes, creating and writing to files, closing file handles, managing process and object references, and memory operations. |
-| [log.rs](https://github.com/DownWithUp/CallMon/blob/main/Rust/src/log.rs) | The provided code snippet is a logging macro that utilizes the `DbgPrint` function from the `winapi` crate. It allows for printing messages to the debugger console with optional formatting and variable interpolation. |
-| [lib.rs](https://github.com/DownWithUp/CallMon/blob/main/Rust/src/lib.rs) | This code snippet is a kernel-mode driver that creates a device and handles various device I/O control requests. It also includes functions to add and remove processes, and supports a custom handler. |
-| [string.rs](https://github.com/DownWithUp/CallMon/blob/main/Rust/src/string.rs) | This code snippet defines a function that creates a Unicode string from a slice of u16 values. It determines the length of the string, sets the length and maximum length fields of a UNICODE_STRING struct accordingly, and assigns the buffer pointer to the start of the string. |
-| [defines.rs](https://github.com/DownWithUp/CallMon/blob/main/Rust/src/defines.rs) | The provided code snippet defines various structs, unions, and constants that are used for interacting with Windows kernel-mode APIs. It includes custom structs and unions that are not provided by the `winapi` crate. These definitions are necessary for utilizing specific functionality in kernel-mode programming. |
+| File | Summary |
+| --- | --- |
+| [externs.rs](https://github.com/DownWithUp/CallMon/blob/main/Rust/src/externs.rs) | This code provides bindings to various WinAPI functions for device creation, process suspension and resumption, file operations, and object handling. It also includes memory and process-related functions for managing kernel mode drivers efficiently. |
+| [log.rs](https://github.com/DownWithUp/CallMon/blob/main/Rust/src/log.rs) | This code provides a logging functionality utilizing Windows DbgPrint API. It includes a macro that allows printing formatted messages to the debug console, with support for variable arguments. |
+| [lib.rs](https://github.com/DownWithUp/CallMon/blob/main/Rust/src/lib.rs) | The code is a driver that handles various functionalities such as handling IRP requests, creating and closing a named pipe, suspending and resuming processes, and registering an alternative system call handler. It also includes error handling and initialization functions. |
+| [string.rs](https://github.com/DownWithUp/CallMon/blob/main/Rust/src/string.rs) | The code defines a function that creates a UNICODE_STRING structure from a slice of UTF-16 encoded Unicode characters. It calculates the length of the string, removes any null terminator if present, and then initializes the fields of the UNICODE_STRING struct with appropriate values. |
+| [defines.rs](https://github.com/DownWithUp/CallMon/blob/main/Rust/src/defines.rs) | This code defines various structs, unions, and constants that are required for interacting with the Windows operating system. It includes definitions for process and thread identifiers, object handle information, trap frames, and custom headers. Overall, it provides the necessary building blocks for working with Windows internals. |
Gui
-| File | Summary |
-| --- | --- |
-| [Utils.h](https://github.com/DownWithUp/CallMon/blob/main/GUI/Utils.h) | The code snippet includes functionalities to obtain device access, create a named pipe, add processes, load a driver, and define data structures. It also includes a helper function for inserting a column in a list view. |
-| [Resource.rc](https://github.com/DownWithUp/CallMon/blob/main/GUI/Resource.rc) | This code snippet is a Microsoft Visual C++ generated resource script. It contains the definition and layout of a dialog box for a software application called "CallMon". The dialog box includes various controls such as buttons, text fields, and a list view. It also defines the design info and layout for the dialog box. |
-| [resource.h](https://github.com/DownWithUp/CallMon/blob/main/GUI/resource.h) | The provided code snippet is a resource file for a Windows application. It defines various IDs for dialog controls, such as buttons, edit boxes, and lists. These IDs are used to reference and manipulate these controls within the application's code. |
-| [CallMon.c](https://github.com/DownWithUp/CallMon/blob/main/GUI/CallMon.c) | The provided code snippet is a Windows application that creates a GUI dialog to display information about system call events. It sets up the GUI and handles various window messages, including button clicks and resizing. It also communicates with a driver to capture and display data about system calls made by different processes. |
+| File | Summary |
+| --- | --- |
+| [Utils.h](https://github.com/DownWithUp/CallMon/blob/main/GUI/Utils.h) | This code includes functionality to create a driver handle, create a named pipe, add a process to the driver, obtain driver privilege, and load the driver. It also includes structures for stack chunks and custom headers, as well as a function to insert a column in a ListView. |
+| [Resource.rc](https://github.com/DownWithUp/CallMon/blob/main/GUI/Resource.rc) | The code is a resource script for a Windows application. It defines the layout and controls for a dialog window called "CallMon". The dialog includes a group box, buttons, an edit box, a list view, and a memo control. It provides functionality for initializing, adding and removing processes, capturing stack information, and clearing data. |
+| [resource.h](https://github.com/DownWithUp/CallMon/blob/main/GUI/resource.h) | The code consists of a dialog-based application with various controls such as buttons, edit boxes, and a list. The core functionalities include initializing the application, adding items to the list, removing items from the list, and clearing the list. There is also a memo stack control for displaying additional information. |
+| [CallMon.c](https://github.com/DownWithUp/CallMon/blob/main/GUI/CallMon.c) | HTTPStatus Exception: 400 |
Root
-| File | Summary |
-| --- | --- |
-| [App.tsx](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/App.tsx) | The code snippet sets up the navigation and screens for a React Native app. It uses react-navigation to create a stack navigator with two screens: Home and Information. The Home screen has a custom header with a title and an "About" button that navigates to the Information screen. The Information screen has a custom header with a title. The data for the app is managed using a DataProvider context. |
+| File | Summary |
+| --- | --- |
+| [App.tsx](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/App.tsx) | This code sets up a React Native app with navigation using React Navigation. It creates a stack navigator with two screens, HomeScreen and Information, and sets the header styles and options for each screen. It also wraps the app with a DataProvider context for managing data. |
Types
-| File | Summary |
-| --- | --- |
-| [types.d.ts](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/types/types.d.ts) | The code snippet defines interfaces for a user and their message. The MessageType interface includes properties for the message's ID, creation timestamp, model, text content, the user who sent the message, and the usage statistics of the message. These statistics include the number of tokens used for prompting and completion, as well as the total tokens used in the message. |
+| File | Summary |
+| --- | --- |
+| [types.d.ts](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/types/types.d.ts) | The code defines the structure of a MessageType object, which represents a message in a chat application. It includes properties for ID, creation timestamp, model used, text content, user information, and usage statistics. The User and Usage interfaces further define the structure of the user and usage data within the MessageType object. |
Context
-| File | Summary |
-| --- | --- |
-| [DataProvider.tsx](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/context/DataProvider.tsx) | The code snippet defines a `DataProvider` component and a corresponding `DataContext` which acts as a global state for the text input. It utilizes the `useState` hook to manage the state. The `DataProvider` component wraps its children with the `DataContext.Provider` and provides the textInput state and setTextInput function as values to its descendant components. This allows the descendants to access and modify the text input state. |
+| File | Summary |
+| --- | --- |
+| [DataProvider.tsx](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/context/DataProvider.tsx) | This code defines a DataProvider component using React's Context API. It creates a context object named DataContext and a provider component that wraps its children. The provider component provides a state variable called textInput and a function called setTextInput to update the state. These can be accessed by any components that are descendants of the DataProvider component. |
Constants
-| File | Summary |
-| --- | --- |
-| [constants.ts](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/constants/constants.ts) | The code snippet provides the API_URL constant, defining the URL address of the API server. This allows easy access and communication with the server for data retrieval or manipulation in the application. |
+| File | Summary |
+| --- | --- |
+| [constants.ts](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/constants/constants.ts) | The code defines the API_URL constant as'http://10.0.2.2:3000', indicating the endpoint for accessing the API. |
Server
-| File | Summary |
-| --- | --- |
-| [index.js](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/server/index.js) | This code snippet sets up an Express server using Node.js to create an API endpoint. It handles HTTP requests, which include receiving chat messages and using OpenAI's API to generate responses. The generated response is then returned as a JSON object. The code also includes error handling and logging functionality. |
-| [config.js](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/server/config.js) | This code snippet initializes the configuration from the.env file and exports key environment variables: OPENAI_API_KEY and OPENAI_ORGANIZATION. |
+| File | Summary |
+| --- | --- |
+| [index.js](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/server/index.js) | This code sets up an Express server that handles API requests for a chatbot powered by OpenAI's GPT-3. It uses the OpenAI API to generate responses based on user input, and returns the response along with metadata such as timestamp and user information. The server listens on port 3000 and supports CORS for cross-origin requests. |
+| [config.js](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/server/config.js) | This code imports the'dotenv' module to load environment variables from a '.env' file. It exports an object containing the OpenAI API key and organization from the environment variables. |
Screens
-| File | Summary |
-| --- | --- |
-| [Infomation.tsx](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/screens/Infomation.tsx) | This code snippet creates a React Native component called "Infomation" that renders a View containing a Text component saying "Infomation". It styles the View container to use flexbox to center its contents vertically and horizontally. This component can be used to display information in a visually appealing manner. |
-| [HomeScreen.tsx](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/screens/HomeScreen.tsx) | The provided code snippet is a functional React Native component called HomeScreen. It imports and renders three components-Layout, ListMessage, and InputMessage-inside a Layout component. The purpose of this code is to display a list of messages and provide a text input field for sending new messages. |
+| File | Summary |
+| --- | --- |
+| [Infomation.tsx](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/screens/Infomation.tsx) | This code is a React Native component that renders a simple "Information" view with centered text. It utilizes the `View`, `Text`, and `StyleSheet` components from React Native. The `styles` object defines the style rules for the container, making it flexbox-based and centered. It is exported as the default component for external use. |
+| [HomeScreen.tsx](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/screens/HomeScreen.tsx) | This code is for the HomeScreen component in a React Native app. It renders a Layout component that contains both the ListMessage and InputMessage components. The ListMessage component displays a list of messages, while the InputMessage component allows users to input new messages. |
Components
-| File | Summary |
-| --- | --- |
-| [InputMessage.tsx](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/components/InputMessage.tsx) | This code snippet is a React component that renders an input field and a send button for sending messages. It utilizes useState and useContext hooks to handle state and context management respectively. When the send button is pressed, it creates a new message object and updates the context data. The input field and send button have corresponding styles applied to them using StyleSheet. |
-| [Layout.tsx](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/components/Layout.tsx) | The code snippet defines a React component called Layout that provides a basic app layout. It includes a container View with specific styling, a StatusBar component to control the status bar appearance, and a dynamic children prop to render any child components within the Layout component. |
-| [Message.tsx](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/components/Message.tsx) | This code snippet defines a React Native component called "Message". It renders a chat message with the author's name and avatar. The message's text can be copied to the clipboard when the user taps on it. The styling includes different backgrounds for messages sent by the user and received from others. |
-| [ListMessage.tsx](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/components/ListMessage.tsx) | The code snippet is a functional component written in JavaScript using React and React Native. It imports necessary modules and contains a `ListMessage` component that renders a list of messages. It utilizes state hooks for managing the list of messages and a context hook for accessing a data provider. It also uses an effect hook for updating the list of messages based on changes in the text input and fetched data. The component renders a `FlatList` to display the messages and includes a refresh control.The code snippet focuses on fetching messages and updating the message list dynamically. |
+| File | Summary |
+| --- | --- |
+| [InputMessage.tsx](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/components/InputMessage.tsx) | The code defines a React component that allows users to input and send messages. It utilizes React hooks to manage state and Context API for data management. The component renders a text input field and a send button. When the button is pressed, the inputted text is sent as a message object to the data context. The component also applies styling using React Native's StyleSheet. |
+| [Layout.tsx](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/components/Layout.tsx) | The code defines a reusable layout component in React Native. It includes a container view with styling for background color, padding, and alignment. It also adds a status bar with a specified background color and content style. The layout component can wrap other components and render them within the container view. |
+| [Message.tsx](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/components/Message.tsx) | This code is a React Native component for rendering a chat message. It displays the message text along with the user's name and avatar. The component also provides an option to copy the message text to the clipboard. The styling is based on the user's role in the chat. |
+| [ListMessage.tsx](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/components/ListMessage.tsx) | This code is responsible for rendering a list of messages in a React Native app. It uses the useState and useEffect hooks to manage the messages state and fetch new messages. The useFetchMessage hook is used to retrieve messages based on a text input. The messages are displayed in a FlatList component, with each message rendered using the Message component. The code also includes a refresh control for pulling to refresh the message list. |
Hooks
-| File | Summary |
-| --- | --- |
-| [useFetchMessage.ts](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/hooks/useFetchMessage.ts) | This code snippet is a custom hook called useFetchMessage that handles fetching a message based on the input provided. It uses useState and useEffect hooks to manage the loading state and trigger the message retrieval. The fetch request is made using the getMessage function from a helper file. The hook returns the fetched message data and a loading status. |
+| File | Summary |
+| --- | --- |
+| [useFetchMessage.ts](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/hooks/useFetchMessage.ts) | This code utilizes React's useState and useEffect hooks to fetch a message based on a given input. It returns a state object with the fetched message data and a loading state. |
Helpers
-| File | Summary |
-| --- | --- |
-| [getMessage.ts](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/helpers/getMessage.ts) | This code snippet defines a function named "getMessage" that takes a message as input. It sends a HTTP POST request to an API endpoint, passing the input message and some parameters. It then returns the response data from the API. The said API is used to generate a message using a language model. |
+| File | Summary |
+| --- | --- |
+| [getMessage.ts](https://github.com/Yuberley/ChatGPT-App-React-Native-TypeScript/blob/main/helpers/getMessage.ts) | The code exports a function called getMessage that sends a message to an API for chatbot responses. It includes the message content, model details, and other parameters. The function makes a POST request to the API URL and returns the response data. |
+ 
+ 
+
+
+
+
+
-
+
+
+
+
+
-
-
+
+
+