DEV Community: Tonic

excellent human-written post about a very under-rated topic 👇🏻

Tonic — Mon, 23 Jun 2025 19:45:06 +0000

Kyle Pena

Jun 23 '25

Gradient Descent on Token Input Embeddings

#llm #machinelearning #deeplearning

Comments 1

9 min read

Clearing GitHub Notifications with a Shell Script: An Introduction to Underutilized GitHub API Endpoints

Tonic — Sun, 08 Sep 2024 08:00:07 +0000

If you’re an active GitHub user, chances are you’ve experienced notification overload at some point. While GitHub’s notification system helps keep you up to date on all the repositories you follow, it can get overwhelming quickly. Thankfully, GitHub provides a robust API that allows us to manage notifications (among many other things) in ways that are not always obvious in the user interface.

In this post, we’ll cover how to use a simple shell script to clear GitHub notifications using the GitHub API. We’ll also explore some lesser-known and underutilized areas of the GitHub API that can help you automate and streamline your development workflows.

Clearing GitHub Notifications with a Shell Script

Imagine you have a backlog of unread GitHub notifications, and no matter what you do, the notification count won’t clear. Luckily, GitHub provides a dedicated Notifications API that allows developers to interact with their notification feed. Using this API, we can mark notifications as read with a single API call.

Let’s walk through a simple shell script that takes a GitHub Personal Access Token (PAT) as an argument and clears all notifications.

The Shell Script

#!/bin/bash

# Check if the token was passed as an argument
if [ -z "$1" ]; then
  echo "Usage: $0 <GitHub Personal Access Token>"
  exit 1
fi

# GitHub Personal Access Token
TOKEN=$1

# Get the current date and time in ISO 8601 format
now=$(date +%Y-%m-%dT%H:%M:%SZ)

# cURL command to mark all notifications as read
curl -H "Authorization: bearer $TOKEN" \
     -X PUT \
     -H "Accept: application/vnd.github.v3+json" \
     https://api.github.com/notifications \
     -d '{"last_read_at":"'"$now"'"}'

echo "All notifications have been marked as read!"

How It Works

Personal Access Token (PAT): The script expects your PAT as an argument. You can create one by following this guide. Make sure it has the appropriate permissions for notifications.
Current Timestamp: The script grabs the current date and time in the ISO 8601 format (YYYY-MM-DDTHH:MM:SSZ) to mark notifications as read up to that point.
API Call: Using the curl command, the script sends a PUT request to the GitHub API with the last_read_at parameter set to the current timestamp. This effectively marks all notifications as read.

How to Use the Script

Save the script to a file, for example, clear_github_notifications.sh.
Give the script execution permission by running:

   chmod +x clear_github_notifications.sh

Run the script and pass your GitHub PAT as an argument:

   ./clear_github_notifications.sh <your-github-personal-access-token>

After running the script, all your notifications will be marked as read, clearing your inbox and resetting the notification count.

Exploring Other Underutilized Areas of the GitHub API

The GitHub API is incredibly powerful, yet many of its features are underutilized by developers. Here are a few lesser-known API endpoints and use cases that can help you take your GitHub automation to the next level.

1. Automating Repository Management with the Repositories API

The Repositories API is a rich part of the GitHub API, yet many people don’t use it to its full potential. Here are some handy things you can do with this API:

Automatically Archiving Repositories: When a project reaches its end of life, you can archive it automatically. This endpoint allows you to archive a repository by sending a simple API request.

   curl -X PUT -H "Authorization: bearer $TOKEN" \
        https://api.github.com/repos/yourusername/repo-name/archive

Automatically Creating Repositories: You can automate the creation of repositories using the API. This is great if you manage multiple projects and want to create new repositories based on templates.

   curl -X POST -H "Authorization: bearer $TOKEN" \
        -d '{"name": "new-repo", "auto_init": true}' \
        https://api.github.com/user/repos

2. Managing Workflow Runs with the Actions API

GitHub Actions is a powerful automation tool, but did you know you can manage your workflows directly from the API? The Actions API allows you to list, rerun, or cancel workflow runs.

Rerun a Workflow: Need to rerun a failed workflow? You can trigger a rerun directly from the API.

   curl -X POST -H "Authorization: bearer $TOKEN" \
        https://api.github.com/repos/yourusername/repo-name/actions/runs/workflow_id/rerun

Get Workflow Logs: Retrieve logs for a specific workflow run and diagnose issues without even opening the GitHub UI.

   curl -H "Authorization: bearer $TOKEN" \
        https://api.github.com/repos/yourusername/repo-name/actions/runs/workflow_id/logs

3. Tracking Issues and Pull Requests with the Issues API

The Issues API is a lifesaver if you’re tracking multiple projects and issues. With this API, you can:

Automatically Assign Issues: Automatically assign issues to team members based on predefined criteria.

   curl -X POST -H "Authorization: bearer $TOKEN" \
        -d '{"assignees": ["username"]}' \
        https://api.github.com/repos/yourusername/repo-name/issues/issue_number

Label Issues: Automatically label issues to prioritize or categorize them for easier tracking.

   curl -X POST -H "Authorization: bearer $TOKEN" \
        -d '{"labels": ["bug", "priority"]}' \
        https://api.github.com/repos/yourusername/repo-name/issues/issue_number/labels

4. Interacting with GitHub Discussions Using the Discussions API

GitHub Discussions is an increasingly popular feature for community engagement, and the Discussions API makes it easy to automate and manage discussions.

Creating a New Discussion: Use the API to create new discussions for community input or project-related queries.

   curl -X POST -H "Authorization: bearer $TOKEN" \
        -d '{"title": "New Discussion", "body": "Let's talk about this!", "category_id": 123}' \
        https://api.github.com/repos/yourusername/repo-name/discussions

While GitHub’s user interface is powerful, there are plenty of ways to extend and automate your workflows using the GitHub API. Whether you want to clear notifications, automate repository management, rerun workflows, or manage issues and discussions, the API provides endless possibilities.

The simple shell script we provided is just one example of how you can start harnessing the power of the GitHub API. From automating tedious tasks to implementing custom workflows, the GitHub API can transform the way you manage your projects and collaborate with your team.

Start exploring, experiment with different API endpoints, and you’ll soon discover a world of automation opportunities on GitHub!

Self-Hosting Forem on AWS

Tonic — Sat, 10 Aug 2024 20:52:39 +0000

These instructions will guide you through deploying a production-ready Forem instance on Amazon Web Services (AWS).

Prerequisites

An AWS account
AWS CLI installed and configured
Basic knowledge of AWS services
Domain name registered and configured in Route 53

1. Set up VPC and Networking

# Create VPC
aws ec2 create-vpc --cidr-block 10.0.0.0/16 --tag-specifications 'ResourceType=vpc,Tags=[{Key=Name,Value=forem-vpc}]'

# Create public subnet
aws ec2 create-subnet --vpc-id <vpc-id> --cidr-block 10.0.1.0/24 --availability-zone us-east-1a

# Create internet gateway
aws ec2 create-internet-gateway --tag-specifications 'ResourceType=internet-gateway,Tags=[{Key=Name,Value=forem-igw}]'

# Attach internet gateway to VPC
aws ec2 attach-internet-gateway --vpc-id <vpc-id> --internet-gateway-id <igw-id>

# Create route table and add route to internet
aws ec2 create-route-table --vpc-id <vpc-id>
aws ec2 create-route --route-table-id <rtb-id> --destination-cidr-block 0.0.0.0/0 --gateway-id <igw-id>

# Associate route table with subnet
aws ec2 associate-route-table --subnet-id <subnet-id> --route-table-id <rtb-id>

2. Create Security Group

aws ec2 create-security-group --group-name forem-sg --description "Security group for Forem" --vpc-id <vpc-id>

# Allow inbound traffic
aws ec2 authorize-security-group-ingress --group-id <sg-id> --protocol tcp --port 22 --cidr 0.0.0.0/0
aws ec2 authorize-security-group-ingress --group-id <sg-id> --protocol tcp --port 80 --cidr 0.0.0.0/0
aws ec2 authorize-security-group-ingress --group-id <sg-id> --protocol tcp --port 443 --cidr 0.0.0.0/0

3. Launch EC2 Instance

aws ec2 run-instances --image-id ami-0261755bbcb8c4a84 --count 1 --instance-type t3.large --key-name <your-key-pair> --security-group-ids <sg-id> --subnet-id <subnet-id> --associate-public-ip-address --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=forem-instance}]'

4. Allocate Elastic IP

aws ec2 allocate-address
aws ec2 associate-address --instance-id <instance-id> --allocation-id <eipalloc-id>

5. Configure DNS

Add an A record in Route 53 pointing your domain to the Elastic IP address.

6. SSH into the Instance

ssh -i <your-key-pair.pem> ubuntu@<public-ip>

7. Install Dependencies

sudo apt update && sudo apt upgrade -y
sudo apt install -y git curl build-essential pkg-config libssl-dev libz-dev libreadline-dev libcurl4-openssl-dev uuid-dev icu-devtools imagemagick nginx postgresql redis-server

8. Install mise

Follow the mise installation instructions from their official documentation.

9. Clone Forem Repository

git clone https://github.com/forem/forem.git
cd forem

10. Install Tool Dependencies

mise install

11. Set Up Database

sudo -u postgres psql
CREATE DATABASE forem_production;
CREATE USER forem WITH PASSWORD 'your_secure_password';
GRANT ALL PRIVILEGES ON DATABASE forem_production TO forem;
\q

12. Set Up Environment Variables

Create a .env.production file in the Forem directory and add necessary environment variables:

RAILS_ENV=production
DATABASE_URL=postgresql://forem:your_secure_password@localhost/forem_production
REDIS_URL=redis://localhost:6379
SECRET_KEY_BASE=<generate_a_secure_key>
FOREM_DOMAIN=your_domain.com

13. Set Up Application

bundle install --deployment --without development test
yarn install
RAILS_ENV=production bundle exec rails assets:precompile
RAILS_ENV=production bundle exec rails db:setup

14. Set Up Nginx as Reverse Proxy

Create an Nginx configuration file:

sudo nano /etc/nginx/sites-available/forem

Add the following configuration:

server {
    listen 80;
    server_name your_domain.com;

    location / {
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Enable the site:

sudo ln -s /etc/nginx/sites-available/forem /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

15. Set Up SSL with Let's Encrypt

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d your_domain.com

16. Set Up Forem as a Service

Create a systemd service file:

sudo nano /etc/systemd/system/forem.service

Add the following content:

[Unit]
Description=Forem
After=network.target

[Service]
Type=simple
User=ubuntu
WorkingDirectory=/home/ubuntu/forem
ExecStart=/home/ubuntu/forem/bin/rails server -e production
Restart=on-failure

[Install]
WantedBy=multi-user.target

Enable and start the service:

sudo systemctl daemon-reload
sudo systemctl enable forem
sudo systemctl start forem

17. Set Up Sidekiq as a Service

Create a systemd service file for Sidekiq:

sudo nano /etc/systemd/system/sidekiq.service

Add the following content:

[Unit]
Description=Sidekiq
After=network.target

[Service]
Type=simple
User=ubuntu
WorkingDirectory=/home/ubuntu/forem
ExecStart=/home/ubuntu/.mise/shims/bundle exec sidekiq -e production
Restart=on-failure

[Install]
WantedBy=multi-user.target

Enable and start the service:

sudo systemctl daemon-reload
sudo systemctl enable sidekiq
sudo systemctl start sidekiq

18. Configure Fastly (Optional)

If you want to use Fastly for caching:

Sign up for a Fastly account
Create a new service in Fastly
Configure your domain in Fastly
Update your DNS to point to Fastly's CDN
Add the Fastly API key to your .env.production file:

FASTLY_API_KEY=your_fastly_api_key
FASTLY_SERVICE_ID=your_fastly_service_id

19. Set Up Email (Optional)

To enable transactional emails, add the following to your .env.production file:

SMTP_ADDRESS=smtp.your_email_provider.com
SMTP_PORT=587
SMTP_DOMAIN=your_domain.com
SMTP_USER_NAME=your_username
SMTP_PASSWORD=your_password
SMTP_AUTHENTICATION=plain

20. Final Steps

Restart your Forem instance:

   sudo systemctl restart forem
   sudo systemctl restart sidekiq

Visit your domain in a web browser to complete the setup process.
Set up an admin account and configure your Forem instance.

Remember to regularly update your Forem instance, monitor your AWS resources, and implement proper backup strategies for your database and user-generated content.

Docker's Testcontainers are Great!

Tonic — Wed, 31 Jul 2024 10:20:06 +0000

🙋🏻‍♂️ Hey there folks , i've really enjoyed using Docker's new opensource startup acquision called test containers.

see below for Links
they want you to use it for testing
i use it for simple AI/ML serving
join me to make more useful and cool testcontainers

What is it ?

Testcontainers is an open source framework for providing throwaway, lightweight instances of databases, message brokers, web browsers, or just about anything that can run in a Docker container.

Testing Layers

leveraging containers for testing enhances reliability, reduces configuration overhead, and improves the consistency of test environments, ultimately leading to more robust and maintainable code.

Test Containers offer significant benefits across different testing layers:

Integration Tests: Containers provide isolated, reproducible environments for data access tests, ensuring consistency and reducing setup complexity.
UI/Acceptance Tests: Containerized browsers enable consistent, reliable UI testing by eliminating variations caused by local browser setups.
Application Integration Tests: Using containers for testing applications with all dependencies allows for accurate, end-to-end testing in environments that closely resemble production.

Data Access Layer Integration Tests

Implications:

Isolation and Consistency: Containerizing your database ensures that each test runs against a fresh, known state. This isolation eliminates the variability and inconsistencies associated with differing local database setups or residual data from previous tests.
Reduced Setup Complexity: Developers avoid the hassle of complex database setups on their local machines, which can lead to a more consistent development experience across the team.
Scalability and Reliability: Tests can be scaled easily without worrying about local resources, and container orchestration tools can manage test database instances efficiently.

Example:
A developer writes integration tests for an application’s data access layer using PostgreSQL. By spinning up a PostgreSQL container for each test, they ensure that each test starts with a clean slate, avoiding conflicts caused by residual data or schema changes from other tests.

UI/Acceptance Tests

Implications:

Consistent Test Environment: Using containerized browsers with tools like Selenium guarantees that UI tests run in a consistent environment, reducing the impact of browser-specific issues or variations caused by different versions or plugins.
Ease of Setup and Maintenance: Containers simplify the setup process for UI tests by providing pre-configured, standardized browser instances, eliminating the need to manually manage browser versions or extensions.
Reproducibility: Each test execution starts with a fresh browser instance, leading to more reliable and reproducible test outcomes.

Example:
An automated UI test suite for a web application is run using containerized Chrome instances. Each test starts with a clean browser, ensuring that issues related to browser cache or extensions do not affect the test results.

Application Integration Tests

Implications:

End-to-End Testing: Containerized environments enable comprehensive testing of the application with all its dependencies (e.g., databases, message queues, web servers) in a single, isolated environment.
Resource Management: Short-lived test containers help manage resources efficiently, avoiding the overhead of long-running services and allowing for quick test execution and teardown.
Environment Parity: Tests can be executed in an environment that closely mimics production, enhancing the accuracy of test results and reducing the risk of discrepancies between test and production environments.

Example:
A microservices-based application is tested using containers for each microservice, along with associated dependencies like a Redis cache and RabbitMQ message broker. This setup allows for end-to-end tests that validate interactions between services in a controlled, isolated environment.

"Very useful , Let's goof off with AI now"

that's great and i'm sure it's useful for saving on DevOps pipelines for production builds and so much more, but i love using it for it's Ollama Object !

Try Testcontainers for AI

The OllamaContainer class from the testcontainers Python library facilitates the setup and management of containerized environments for serving AI models with Ollama. This allows you to run inference tasks in a consistent and isolated environment, making it easier to test and develop AI applications without worrying about local configuration issues.

Testcontainers Object for Ollama AI Serving Inference

The OllamaContainer class provides a streamlined way to interact with a containerized instance of Ollama, which serves AI models for inference. It simplifies tasks such as starting the Ollama service, listing available models, pulling new models, and querying the service for predictions. Below is a detailed description of how to use the OllamaContainer class, along with code snippets illustrating typical use cases.

Features

Container Management:
- Automatically handles the lifecycle of the Ollama container.
- Starts the container and ensures it is properly stopped and cleaned up after use.
Model Management:
- Allows listing available models.
- Supports pulling new models if they are not already available.
Inference Requests:
- Provides methods to interact with the model for inference tasks via HTTP endpoints.

Code Examples

The OllamaContainer class from the testcontainers library is a powerful tool for developers working with AI models, providing a straightforward way to manage containerized environments for inference tasks. By encapsulating the complexity of setup and teardown, it allows developers to focus on building and testing their applications with reliable and reproducible results.

Basic Usage

The following code snippet demonstrates how to use the OllamaContainer class to set up an environment, list available models, and perform inference tasks.


from json import loads
from pathlib import Path
from requests import post, RequestException
from testcontainers.ollama import OllamaContainer

def split_by_line(generator):
    data = b''
    for each_item in generator:
        for line in each_item.splitlines(True):
            data += line
            if data.endswith((b'\r\r', b'\n\n', b'\r\n\r\n', b'\n')):
                yield from data.splitlines()
                data = b''
    if data:
        yield from data.splitlines()

def main():
    with OllamaContainer(ollama_home=Path.home() / ".ollama") as ollama:
        # List available models
        models = ollama.list_models()
        print("Available models:", models)

        # Choose a specific model, for example 'yi:6b-v1.5'
        model_name = "yi:6b-v1.5"
        if model_name not in [model["name"] for model in models]:
            print(f"Model '{model_name}' not found, pulling the model.")
            ollama.pull_model(model_name)
            print(f"Model '{model_name}' has been pulled.")

        # Use the model to generate responses in an interactive chat
        try:
            endpoint = ollama.get_endpoint()
            print("You can now start chatting with the model. Type 'exit' to quit.")

            while True:
                user_input = input("You: ")
                if user_input.lower() == "exit":
                    print("Exiting chat.")
                    break

                response = post(
                    url=f"{endpoint}/api/chat", 
                    stream=True, 
                    json={
                        "model": model_name,
                        "messages": [{
                            "role": "user",
                            "content": user_input
                        }]
                    }
                )
                response.raise_for_status()

                for chunk in split_by_line(response.iter_content()):
                    model_response = loads(chunk)["message"]["content"]
                    print(f"Model: {model_response}", end="")

        except RequestException as e:
            print(f"An error occurred: {e}")

if __name__ == "__main__":
    main()

Key Methods and Properties

__init__(ollama_home: Path):
- Parameters: ollama_home (Path) - The directory where Ollama configuration and model files are stored.
- Description: Initializes the container with a specified home directory for Ollama.
list_models():
- Returns: A list of available models.
- Description: Retrieves a list of models currently available in the container.
pull_model(model_name: str):
- Parameters: model_name (str) - The name of the model to pull.
- Description: Pulls the specified model if it is not already available.
get_endpoint():
- Returns: A string containing the endpoint URL for accessing the model.
- Description: Provides the URL where the model's inference API can be accessed.
__enter__() and __exit__():
- Description: Handle the context management for the container, starting and stopping it as needed.

The Best Part

Now you can deploy containers directly in your code , remove containers, save on ressources, test with more rigoror , and create your own objects !

Join US

we're pushing our favorite services upstream , and there are a ton of supported languages not just python !
1. Join us on our ⚒️builders' discord
2. Sign up to our gitlab - after saying hi!
3. Follow us on 🤗huggingface and Dev.to 🙏🏻
4. Join our docker projects , and more !

Ask Questions Below ! 👇🏻

have trouble running this script ? ask a lot of questions below, no problem !

Pitch-Tonic

Tonic — Sun, 23 Jun 2024 17:17:01 +0000

we're making a cool app for a hackathon : everyone is welcome to join us !

🎤 Pitch Tonic: Your Ultimate Pitch Training App! 🎤

Elevate your pitching game with Pitch Tonic, the open-source app designed to perfect your live pitches and investor Q&A training. Here's how it works:

Interlocutor Recording & Tips 📹: Record your interlocutor and get real-time tips to improve your pitch.
Pitch Deck Training 🎓: Record yourself practicing your pitch deck and receive constructive feedback.
Knowledge Testing 🧠: Test your pitch knowledge by answering questions and get instant feedback. Choose from easy, medium, or hard levels to challenge yourself.

💡 We Need You! 💡
Pitch Tonic is fully open-source under the MIT license, and we're looking for passionate contributors to help us grow! Whether you're a developer, designer, or pitch enthusiast, join our community and make an impact.

🤝 Get Involved 🤝
Contribute to the code, suggest new features, or provide feedback. Let's make Pitch Tonic the go-to tool for startups everywhere!

🚀 Join Us Today! 🚀

🔗 Contribute on our Gitlab

👥 Get in Touch 👥
Have questions or ideas? request access!

💬 Discord

i got followers here a lot and quickly !

Tonic — Mon, 17 Jun 2024 18:33:04 +0000

this is actually so crazy !!!

thank you all so much !

i'll try to not let you down and keep the cool oss / ai / enterprise / fintech (not crypto, just normal) projects coming and make life on earth !

Code the Vote!

Tonic — Sat, 15 Jun 2024 18:16:04 +0000

🙋🏻‍♂️Making a USA-elections app

basically i was gonna drop off, but then i got roped back in !

we have 24 hours from this post to make it !

it's for a hackathon on devpost : https://code-the-vote.devpost.com/

here's the repo : https://github.com/Josephrp/oreally.git
here are the open issues : https://github.com/Josephrp/oreally/issues

i'd love to link up with some coders that like #llama-index #ai #voice / #audio #python #streamlit all that :-)

just get in touch :-)

Join our discord builder's server

Tonic — Fri, 14 Jun 2024 12:45:14 +0000

hey there folks, we're Tonic-AI

We started off as an accidental community , but we're growing and supporting eachother, "building in public" and basically learning and ton and publishing a ton of demos and stuff.

sounds good ?

** join us! **

discord

Hey there Folks - It's my First Post !

Tonic — Fri, 14 Jun 2024 10:34:18 +0000

Tonic-AI Community

if actually found dev.to through forem, isnt that cool ?

basically i just started an accidental dev community on discord (i hate discord to be honest) and it kinda took off, we're making like 10 demos a week on good weeks and 2 or 3 on bad weeks, so the volume on code repos is really there :-)

proud of us & now we have a community organisation on dev.to

really loving everything i see here so far !

looking forward to contributing cool posts and learning a ton !

DEV Community: Tonic

excellent human-written post about a very under-rated topic 👇🏻

Gradient Descent on Token Input Embeddings

Clearing GitHub Notifications with a Shell Script: An Introduction to Underutilized GitHub API Endpoints

Clearing GitHub Notifications with a Shell Script

The Shell Script

How It Works

How to Use the Script

Exploring Other Underutilized Areas of the GitHub API

1. Automating Repository Management with the Repositories API

2. Managing Workflow Runs with the Actions API

3. Tracking Issues and Pull Requests with the Issues API

4. Interacting with GitHub Discussions Using the Discussions API

Self-Hosting Forem on AWS

Prerequisites

1. Set up VPC and Networking

2. Create Security Group

3. Launch EC2 Instance

4. Allocate Elastic IP

5. Configure DNS

6. SSH into the Instance

7. Install Dependencies

8. Install mise

9. Clone Forem Repository

10. Install Tool Dependencies

11. Set Up Database

12. Set Up Environment Variables

13. Set Up Application

14. Set Up Nginx as Reverse Proxy

15. Set Up SSL with Let's Encrypt

16. Set Up Forem as a Service

17. Set Up Sidekiq as a Service

18. Configure Fastly (Optional)

19. Set Up Email (Optional)

20. Final Steps

Docker's Testcontainers are Great!

What is it ?

Testing Layers

Data Access Layer Integration Tests

UI/Acceptance Tests

Application Integration Tests

"Very useful , Let's goof off with AI now"

Try Testcontainers for AI

Testcontainers Object for Ollama AI Serving Inference

Features

Code Examples

Basic Usage

Key Methods and Properties

The Best Part

Join US

Links

Ask Questions Below ! 👇🏻

Pitch-Tonic

i got followers here a lot and quickly !

thank you all so much !

Code the Vote!

🙋🏻‍♂️Making a USA-elections app

Join our discord builder's server

hey there folks, we're Tonic-AI

Hey there Folks - It's my First Post !

Tonic-AI Community