Skip to content

Instantly share code, notes, and snippets.

@vivek1986

vivek1986/GithubGistFromFilesInFolder.md

Created October 30, 2024 18:56
Show Gist options
  • Save vivek1986/ccfa75ce58ea23ab6f921a4be3d04112 to your computer and use it in GitHub Desktop.
Save vivek1986/ccfa75ce58ea23ab6f921a4be3d04112 to your computer and use it in GitHub Desktop.
Download ZIP
Gist created from folder
Raw
GithubGistFromFilesInFolder.md

To auto-generate a GitHub Gist from a folder with files, you can use the GitHub API and a scripting language like Python or Bash. Below are the steps to achieve this.

Step 1: Create a GitHub Personal Access Token

  1. Go to GitHub settings.
  2. Click on "Generate new token".
  3. Select the scopes you need. For Gists, you'll generally need the "gist" scope.
  4. Generate the token and save it securely.

Step 2: Script to Create Gist

Using Python

You can use the following Python script to create a Gist from all files in a specified folder:

import os
import requests

# Your GitHub token
TOKEN = 'your_personal_access_token'
# The folder containing files
FOLDER_PATH = 'path/to/your/folder'

def create_gist(folder_path):
    files = {}

    # Iterate over all files in the folder
    for filename in os.listdir(folder_path):
        if os.path.isfile(os.path.join(folder_path, filename)):
            with open(os.path.join(folder_path, filename), 'r') as f:
                files[filename] = {
                    'content': f.read()
                }

    # Create the Gist
    gist_data = {
        'description': 'Gist created from folder',
        'public': True,
        'files': files
    }

    response = requests.post(
        'https://api.github.com/gists',
        json=gist_data,
        headers={'Authorization': f'token {TOKEN}'}
    )

    if response.status_code == 201:
        print('Gist created successfully:', response.json()['html_url'])
    else:
        print('Error creating Gist:', response.content)

if __name__ == '__main__':
    create_gist(FOLDER_PATH)

Using Bash (cURL)

If you prefer a Bash script, you can use the following cURL command in a loop:

#!/bin/bash

# Your GitHub token
TOKEN='your_personal_access_token'
# The folder containing files
FOLDER_PATH='path/to/your/folder'

declare -A files

# Read all files in the folder
for file in "$FOLDER_PATH"/*; do
    filename=$(basename "$file")
    content=$(<"$file")
    files["$filename"]="$content"
done

# Prepare JSON data
json_data="{\"description\": \"Gist created from folder\", \"public\": true, \"files\": {"
for filename in "${!files[@]}"; do
    json_data+="\"$filename\": {\"content\": \"${files[$filename]}\"},"
done
json_data="${json_data%,}}}"

# Create the Gist
response=$(curl -s -X POST -H "Authorization: token $TOKEN" -d "$json_data" https://api.github.com/gists)

# Check if the Gist was created successfully
if echo "$response" | grep -q '"html_url":'; then
    echo "Gist created successfully: $(echo "$response" | grep '"html_url":' | awk -F '"' '{print $4}')"
else
    echo "Error creating Gist: $response"
fi

Step 3: Run the Script

  1. Make sure to replace your_personal_access_token with your actual GitHub token and path/to/your/folder with the path to the folder you want to upload.
  2. Save the script as create_gist.py (for Python) or create_gist.sh (for Bash).
  3. For Bash, give execute permission: 
    chmod +x create_gist.sh
  4. Run the script:
    • For Python: 
      python create_gist.py
    • For Bash: 
      ./create_gist.sh

Summary

This process will create a GitHub Gist containing all the files from the specified folder. Make sure to check the GitHub API documentation for further customization options. If you have any questions or need further assistance, feel free to ask!

Raw
index.php
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Email Verification</title>
<link rel="stylesheet" href="styles.css">
<script src="https://code.jquery.com/jquery-3.7.1.min.js"></script>
</head>
<body>
<div class="container">
<h1>Email Verification</h1>
<input type="email" id="email" placeholder="Enter your email" required>
<button id="verifyBtn">Verify Email</button>
<div id="result"></div>
</div>
<script>
$(document).ready(function() {
$('#verifyBtn').click(function() {
const email = $('#email').val();
if (email) {
$.ajax({
url: 'myemailverifier.verify.php',
type: 'POST',
data: { email: email },
success: function(response) {
$('#result').html(response);
},
error: function() {
$('#result').html('<p class="error">An error occurred. Please try again.</p>');
}
});
} else {
$('#result').html('<p class="error">Please enter a valid email.</p>');
}
});
});
</script>
</body>
</html>
Raw
PythonVirtualEnvOptions.md

To avoid installing every pip dependency globally in Python, you can use virtual environments. Virtual environments allow you to create isolated environments for your projects, ensuring that dependencies are managed independently. Here are some popular tools to create and manage virtual environments:

  1. venv (built-in module):

    • To create a virtual environment: 
      python -m venv myenv
    • To activate it:
      • On Windows: 
        myenv\Scripts\activate
      • On macOS/Linux: 
        source myenv/bin/activate

  2. virtualenv (an alternative to venv):

    • First, install it globally if you haven't already: 
      pip install virtualenv
    • Then create a virtual environment: 
      virtualenv myenv
    • Activate it in the same way as with venv.

  3. conda (if you're using Anaconda):

    • To create a new environment: 
      conda create --name myenv
    • To activate it: 
      conda activate myenv

Using any of these methods allows you to manage dependencies per project, avoiding conflicts and ensuring a clean development environment.

Here's a detailed comparison of the three tools for managing Python environments: venv, virtualenv, and conda.

1. venv

  • Built-in: Comes pre-installed with Python 3.3 and later.
  • Usage:
    • Create a virtual environment: 
      python -m venv myenv
    • Activate:
      • Windows: myenv\Scripts\activate
      • macOS/Linux: source myenv/bin/activate
  • Dependencies:
    • Only manages Python packages and dependencies. It uses the standard pip for installation.
  • Isolation: Creates a directory containing a copy of the Python interpreter, pip, and other necessary files.
  • Pros:
    • Lightweight and easy to use.
    • No additional installation required.
  • Cons:
    • Limited to Python. Doesn't manage non-Python dependencies (e.g., libraries like numpy that may rely on system libraries).

2. virtualenv

  • External Library: Must be installed separately using pip.
  • Usage:
    • Install: 
      pip install virtualenv
    • Create a virtual environment: 
      virtualenv myenv
    • Activate: Same activation method as venv.
  • Dependencies:
    • Like venv, it uses pip for managing Python packages but provides some additional features.
  • Isolation: Similar isolation as venv.
  • Pros:
    • Supports older versions of Python (2.x).
    • Can create environments with different Python versions if you have multiple installed.
  • Cons:
    • Slightly more overhead since it requires an additional installation.

3. conda

  • Package Manager: Part of the Anaconda distribution, but can also be used independently with Miniconda.
  • Usage:
    • Create a new environment: 
      conda create --name myenv
    • Activate: 
      conda activate myenv
  • Dependencies:
    • Manages both Python packages and non-Python dependencies (like libraries and binaries).
  • Isolation: Similar concept, but can manage multiple versions of Python and other packages within the same environment.
  • Pros:
    • Very powerful for data science, machine learning, and scientific computing, where you often need libraries that have complex dependencies.
    • Easier to install some non-Python packages (like numpy, scipy, etc.) without dealing with system-level installations.
  • Cons:
    • Larger installation size compared to venv and virtualenv.
    • Can be overkill for simple projects or web applications.

Summary

  • Use venv for simple projects where you need lightweight, isolated environments.
  • Use virtualenv if you need to support older Python versions or require some of its additional features.
  • Use conda for data science and complex projects requiring both Python and non-Python package management.
Raw
styles.css
body {
font-family: Arial, sans-serif;
background-color: #f4f4f4;
margin: 0;
padding: 20px;
}
.container {
max-width: 400px;
margin: auto;
padding: 20px;
background: #fff;
border-radius: 8px;
box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
}
h1 {
text-align: center;
}
input[type="email"] {
width: 100%;
padding: 10px;
margin: 10px 0;
border: 1px solid #ccc;
border-radius: 4px;
}
button {
width: 100%;
padding: 10px;
background: #28a745;
border: none;
color: white;
font-size: 16px;
border-radius: 4px;
cursor: pointer;
}
button:hover {
background: #218838;
}
#result {
margin-top: 20px;
}
.valid {
color: green;
}
.invalid {
color: red;
}
.error {
color: red;
}
Raw
ZeroBounceAPI_PHP_Email_Check.md

Sure! Here’s a simple example of how to use the ZeroBounce API for email verification in PHP, including error handling and a basic unit test.

Step 1: Setting Up

First, ensure you have the following:

  • A ZeroBounce API key.
  • PHP installed on your server.
  • Composer for dependency management (if you want to use a library).

Step 2: Install GuzzleHTTP

To make HTTP requests, you can use Guzzle. Install it via Composer:

composer require guzzlehttp/guzzle

Step 3: Email Verification Code

Here's a sample PHP script for email verification using the ZeroBounce API:

<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;
use GuzzleHttp\Exception\RequestException;

class EmailVerifier {
    private $apiKey;
    private $client;

    public function __construct($apiKey) {
        $this->apiKey = $apiKey;
        $this->client = new Client();
    }

    public function verifyEmail($email) {
        $url = 'https://api.zerobounce.net/v2/validate';

        try {
            $response = $this->client->request('GET', $url, [
                'query' => [
                    'api_key' => $this->apiKey,
                    'email' => $email,
                ]
            ]);

            $data = json_decode($response->getBody(), true);
            return $data;

        } catch (RequestException $e) {
            // Log error or handle it accordingly
            return [
                'status' => 'error',
                'message' => $e->getMessage(),
            ];
        }
    }
}

// Usage example
$apiKey = 'your_api_key_here';
$emailVerifier = new EmailVerifier($apiKey);
$result = $emailVerifier->verifyEmail('[email protected]');
print_r($result);

Step 4: Unit Testing

You can use PHPUnit for unit testing. Install it via Composer if you haven't:

composer require --dev phpunit/phpunit

Then, create a test case for your EmailVerifier class:

<?php

use PHPUnit\Framework\TestCase;

class EmailVerifierTest extends TestCase {
    public function testVerifyEmailSuccess() {
        $apiKey = 'your_api_key_here';
        $emailVerifier = new EmailVerifier($apiKey);
        $result = $emailVerifier->verifyEmail('[email protected]');

        $this->assertArrayHasKey('status', $result);
        $this->assertNotEmpty($result['status']);
    }

    public function testVerifyEmailError() {
        $apiKey = 'invalid_api_key';
        $emailVerifier = new EmailVerifier($apiKey);
        $result = $emailVerifier->verifyEmail('invalid_email');

        $this->assertArrayHasKey('status', $result);
        $this->assertEquals('error', $result['status']);
        $this->assertNotEmpty($result['message']);
    }
}

Running the Tests

You can run the tests with the following command:

./vendor/bin/phpunit EmailVerifierTest.php

Summary

  • This code demonstrates how to verify emails using the ZeroBounce API in PHP.
  • It includes basic error handling for API requests.
  • Unit tests are provided to ensure that your email verification logic works correctly.

Make sure to replace 'your_api_key_here' with your actual ZeroBounce API key. Adjust the testing emails and scenarios as needed!

Currently, ChatGPT doesn't offer a direct way to download code files. However, you can easily copy and paste the code provided into your local development environment or code editor.

If you're looking for more convenient options, here are a couple of suggestions:

  1. Use a Code Editor with Snippet Support: Some editors allow you to create snippets, so you can store frequently used code segments and access them easily.

  2. GitHub Gists or Repositories: You can create a GitHub Gist or a repository where you save the code snippets. This allows for version control and easy access whenever you need the code.

  3. Text Files: Simply copy the provided code into text files in your project directory. This way, you can structure your codebase as needed.

If you have any specific requests or need further assistance, feel free to ask!

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment