My Shells

1

libenv.sh

#!/bin/bash

# The library you are searching for
LIBRARY_NAME="example-lib"

# List all conda environments and loop through them
for ENV in $(conda env list | grep -v '#' | awk '{print $1}'); do
  #echo "Checking environment: $ENV"
  # Use conda list to search for the library in the current environment
  if conda list -n $ENV | grep -q $LIBRARY_NAME; then
    echo "Library $LIBRARY_NAME found in environment $ENV"
  #else
  #  echo "Library $LIBRARY_NAME not found in environment $ENV"
  fi
done

How to run?

./libenv.sh pigar

Library pigar found in environment ml311
Library pigar found in environment ner12
Library pigar found in environment ner39
Library pigar found in environment ner391

---

libenv.sh - updated version:

To enhance your shell script so it also reports the version of a specified library in each Conda environment where it's found, you can modify the grep search pattern to extract the version number from the output of conda list. Here’s how you can update your script:

#!/bin/bash

# The library you are searching for
LIBRARY_NAME="$1"

# List all conda environments and loop through them
found_lib_counter=0
for ENV in $(conda env list | awk 'NR > 2 {print $1}'); do  # Improved to skip headers and use awk to filter directly
    # Use conda list to search for the library in the current environment
    version_info=$(conda list -n $ENV | grep "^$LIBRARY_NAME\s")  # Searches for lines starting with the library name followed by whitespace
    if [ ! -z "$version_info" ]; then
        echo "Library $LIBRARY_NAME found in environment $ENV with version: $(echo $version_info | awk '{print $2}')"  # Outputs the version
        ((found_lib_counter++))
    fi
done

if [ $found_lib_counter -eq 0 ]; then
  echo "Library $LIBRARY_NAME not found"
fi

Output:

lf langchain

gpt: 0.1.9
ml311: 0.0.350
ml312: 0.1.9
ml39: 0.1.9

Explanation of Changes:

1. Environment Listing: The script now uses awk 'NR > 2 {print $1}' to skip the header lines in the conda env list output, which makes it more robust against possible changes in the header format.

2. Version Extraction:

   • The grep command now includes ^$LIBRARY_NAME\s to make sure it matches the library name at the start of a line followed by whitespace, which helps to avoid partial matches with other package names.

   • The version number is extracted using awk '{print $2}', assuming that the conda list command outputs the version as the second column.

3. Output: The script now prints the environment and the version of the library if found.

This script will now correctly identify the presence of the specified library and output its version in each Conda environment where it's found. If the library is not present in any environment, it will print "Library $LIBRARY_NAME not found". This is a more robust and informative approach to tracking package installations across multiple environments.

---

2

ctem.sh

```shellscript
#!/bin/zsh

# Run cignore.sh
/home/raja/csp/myshell/cignore.sh

# Run czem.sh
/home/raja/csp/myshell/czem.sh

# create .ant file
touch .ant
```

cignore.sh

```shellscript
cp /home/raja/csp/myshell/.gitignore .

echo  ".gitignore copied"
```

czem.sh

```shellscript
cp /home/raja/csp/myshell/zemplate.py .

echo  "zemplate copied"
```

---

3

mvd.sh

```shellscript
#!/bin/bash

# Destination directory
DEST="$HOME/datasets"

# Check if the destination directory exists, if not, create it
# if [ ! -d "$DEST" ]; then
#   mkdir -p "$DEST"
# fi

# Move the file to the destination directory
if [ -f "$1" ]; then
  mv "$1" "$DEST"
  echo "Moved $1 to $DEST."
else
  echo "Error: File $1 does not exist."
fi
```

---

gu.sh

```shellscript
git_push_with_chatgpt()
{
  
    git pull

    # sleep 3 seconds
    sleep 2

    git add .

    # path to the file
    file_path="/home/raja/csp/gitmagic/gcommit-chatgpt.txt"

    # using wc command to count number of lines
    number_of_lines=`wc -l < $file_path`

    # echo $((number_of_lines))

    rando_number=`shuf -i 1-$((number_of_lines)) -n 1`

    # echo $rando_number

    line=`sed $((rando_number))!d $file_path`
    # echo $line

    git commit -m "$line: Updates for $(date +%F)"

    git push

}

git_push_with_vanilla()
{
    echo "calling Vanilla"
    
    git add .

    git commit -m "Updates for $(date +%F)"

    git push
}

# Testing
# git_push_with_chatgpt
# git_push_with_vanilla

if [ -n "$1" ] ; then
    git_push_with_vanilla
else
    git_push_with_chatgpt
fi
```

---

Release Date Finder

abc.py

The error you're encountering suggests that the script is trying to access the first element of a list that might be empty. This can occur if there is no release data available for the specified version, or if the structure of the JSON response does not match the expectations.

To make your script more robust, you should add checks to ensure that the data you're attempting to access exists and is in the expected format. Here's how you can modify the script to handle these cases properly:

import requests
python
import sys
from datetime import datetime


def convert_date(date_string):

    # Convert string to datetime object
    date_object = datetime.strptime(date_string, "%Y-%m-%dT%H:%M:%S")

    # Format the datetime object to the desired string format
    formatted_date = date_object.strftime("%b %d, %Y")

    return formatted_date


def get_release_date(package_name, version):
    """ Fetch the release date of a specific version of a package from PyPI. """
    url = f"https://pypi.org/pypi/{package_name}/json"
    response = requests.get(url)
    
    if response.status_code == 200:
        data = response.json()
        # Check if the version data and upload_time exist before trying to access them
        releases = data.get('releases', {})
        if version in releases and releases[version]:
            release_date = releases[version][0].get('upload_time', 'No release date found')
            formatted_date = convert_date(release_date)
            # print(f"Version {version} of {package_name} was released on {release_date}")
        else:
            print(f"No release information found for version {version} of {package_name}.")
    else:
        print(f"Failed to fetch data for version {version}. Status code: {response.status_code}")


package_name = sys.argv[1]

if(len(sys.argv) == 2):
    get_release_dates(package_name)
else:
    version = sys.argv[2]
    get_release_date(package_name, version)

Modifications Made:

1. Error Handling: I added a check to see if the specified version is actually in the releases dictionary and if there are any entries for it. This prevents trying to access elements in an empty list.

2. Status Message: The script now provides more descriptive messages for different failure cases, such as missing version information or HTTP request errors.

3. Robustness: By checking if key data points are present before accessing them, the script avoids runtime errors like the IndexError you encountered.

This updated script should be more reliable and informative, helping to identify why a specific version's release date might not be available or if there are issues with the API request itself.

Script:

rdf.sh

To run a Python script within a Conda environment from a shell script, you need to ensure that the script activates the correct Conda environment before executing the Python file. This setup is useful for automation tasks, ensuring that the Python script runs with the right package versions and dependencies managed by Conda.

Here’s a step-by-step guide to creating a shell script that activates a Conda environment and runs a Python script:

Step 1: Locate Your Conda Installation

Before writing the script, make sure you know where Conda is installed. This is especially important if Conda is not initialized in your shell environment or if you're running the script in an environment where the Conda executable isn't in the default PATH.

Step 2: Create the Shell Script

Here is a basic shell script template that activates a Conda environment and runs a Python script:

#!/bin/bash

# Path to the Conda executable
# This might vary depending on where Conda is installed
CONDA_PATH="$HOME/miniconda3/etc/profile.d/conda.sh"  # Adjust this as necessary

# Name of the Conda environment
ENV_NAME="myenv"

# Path to the Python script
PYTHON_SCRIPT="/path/to/your_script.py"

# Check if Conda is available
if [ -f "$CONDA_PATH" ]; then
    # Ensure Conda is available in the script
    source $CONDA_PATH

    # Activate the Conda environment
    conda activate $ENV_NAME

    # Run the Python script
    python $PYTHON_SCRIPT $1 $2

    # Optionally deactivate environment, although script end will do this by default
    conda deactivate
else
    echo "Conda path not found: $CONDA_PATH"
    exit 1
fi

Step 3: Make the Shell Script Executable

After saving your script (let’s say as run_python_script.sh), you need to make it executable:

chmod +x rdf.sh

Step 4: Add them in Zsh

alias rdf="/home/abc/csp/myshell/rdf.sh"

Step 5:

rdf langchain 0.1.9

Additional Notes:

• Conda Initialization: If Conda commands are not recognized, ensure Conda is properly initialized in your shell. You can do this by running conda init <shell_name> where <shell_name> could be bash, zsh, etc.

• Environment Path: Make sure the paths to Conda and your Python script are correctly specified.

• Permissions: The Python script must also be executable, or you must have the appropriate permissions to run it.

• Debugging: If things don’t work as expected, add set -x after the shebang line (#!/bin/bash) to enable debugging in your script, which helps trace what commands are being run.

This setup ensures your Python scripts run within a specific Conda environment, leveraging the environment's specific packages and versions, suitable for both development and production environments where version control is crucial.

---

---

---

---

---

---

---

---

---

---

---

---

---

---

---

---

---

---

---

---

---