ros_conda_wrapper_rc

#!/usr/bin/env bash
## -- ROS Conda wrapper --
# This wrapper was added to solve for the conflicts caused by sourcing a ROS setup.bash file inside a
# Conda environment .

# Set environment variables
export ROS_CONDA_WRAPPER=true

# Set Global variables
ROS_CONDA_WRAPPER_PROGNAME="ROS Conda wrapper"
ROS_CONDA_WRAPPER_ERROR=false
ROS_CONDA_WRAPPER_VERSION="1.0.7"
ROS_CONDA_CONFIG_FILE_NAME="${HOME}/.ros_conda_wrapper_rc_cfg"
ROS_CONDA_ROS_PYTHONPATH_BACKUP=()

# Bash echo colours
ORANGE_CC='\033[0;33m'
NC_CC='\033[0m' # No colour

# Required ROS packages
ROS_CONDA_DEPS=()
ROS_CONDA_FORGE_DEPS=(
	"ros-core"
	"ros-actionlib"
	"ros-dynamic-reconfigure"
)
ROS_CONDA_PIP_DEPS=()

# Perform some clean-up actions
unalias conda 2> /dev/null
unset -f _ros_conda_load_config_vars 2> /dev/null
unset -f _ros_conda_save_config_vars 2> /dev/null
unset -f _ros_conda_usage 2> /dev/null
unset -f _ros_conda_path_fix_outside 2> /dev/null
unset -f _ros_conda_path_fix_inside 2> /dev/null
unset -f _ros_conda_pythonpath_fix_outside 2> /dev/null
unset -f _ros_conda_pythonpath_fix_inside 2> /dev/null
unset -f _ros_conda_is_conda_env 2> /dev/null
unset -f _ros_conda_init 2> /dev/null
unset -f _ros_conda_deinit 2> /dev/null
unset -f _ros_conda_wrapper 2> /dev/null
unset -f _ros_conda_source_wrapper 2> /dev/null
unset -f _ros_conda_dot_source_wrapper 2> /dev/null

###############################################
## Ros Conda wrapper member functions #########
###############################################
_ros_conda_load_config_vars() {

	# Load conda wrapper configuration values
	if [[ -a "$ROS_CONDA_CONFIG_FILE_NAME" ]]; then

		# Read variables from file
		while IFS="=" read -r key val; do
			case "$key" in
				'#'*)
					;; # Skip comments
				'ROS_CONDA_WRAPPER_ACTIVE')
					eval "$key=\"$val\""
					;;
			esac
		done < "$ROS_CONDA_CONFIG_FILE_NAME"

		# Parse variables to make sure they are alright
		case "$ROS_CONDA_WRAPPER_ACTIVE" in
			"true"|"True"|"TRUE"|"false"|"False"|"FALSE")
				;;
			*)
				# Value was not valid set to default
				ROS_CONDA_WRAPPER_ACTIVE=true
				;;
		esac

		# Export variable
		export ROS_CONDA_WRAPPER_ACTIVE
	else

		# Create file
		{
		cat > "$ROS_CONDA_CONFIG_FILE_NAME" <<- EOL
		# Ros Conda wrapper settings
		ROS_CONDA_WRAPPER_ACTIVE=true
		EOL
		} || {
			printf "%s:${ORANGE}warning:${NC} Configuration file could not be loaded. Default values were used instead. %s\n" "$PROGNAME"
		}

		# Use defaults
		export ROS_CONDA_WRAPPER_ACTIVE=true
	fi
}

_ros_conda_save_config_vars() {
	# Save the Conda wrapper configuration values
	{
		cat > "$ROS_CONDA_CONFIG_FILE_NAME" <<- EOL
		# Ros Conda wrapper settings
		ROS_CONDA_WRAPPER_ACTIVE=$ROS_CONDA_WRAPPER_ACTIVE
		EOL
	} || {
		printf "%s:${ORANGE}warning:${NC} Pathmod configuration values could not be saved. %s\n" "$PROGNAME"
	}
}

_ros_conda_usage() {
	# Script that prints usage information
	cat <<- EOF
	usage: $ROS_CONDA_WRAPPER_PROGNAME options

	This wrapper solves some problems people have while trying to use ROS Kinetic/Melodic
	inside a Conda environment.

	OPTIONS:
	   activate                     Activate the ROS Conda wrapper
	   deactivate                   Deactivate the ROS Conda wrapper
	   init <CONDA_ENVIRONMENT>     Initialize a given <CONDA_ENVIRONMENT> to work with ROS
	   deinit <CONDA_ENVIRONMENT>   Deinitailize a given ROS <CONDA_ENVIRONMENT> to work
	   -h, --help                   Displays usage information
	   -v, --version                ROS Conda wrapper version
	EOF
}

function _ros_conda_path_fix_outside() {
	# This function makes sure the anaconda bin and condabin folders
	# are further on the path than the /usr/bin, /bin and
	# /opt/ros/<ROSVERSION>/bin when outside an anaconda environment.

	# Create local variables
	local path_changed=false

	# Split PATH into array and get path length
	local defaultIFS="$IFS"; IFS=$' \t\n'; local path_array=(${PATH//:/ }); IFS="$defaultIFS"
	local arr_len="${#path_array[@]}"

	# Make sure the Conda paths are at the end of the PATH variable
	ros_conda_path_array=(
		"${ROS_CONDA_CONDA_PATH}/condabin"
		"${ROS_CONDA_CONDA_PATH}/bin"
		"${ROS_CONDA_CONDA_PATH}/envs/${CONDA_DEFAULT_ENV}/bin"
	)
	for path in "${ros_conda_path_array[@]}"; do
		if [[ :${PATH}: == *:"${path}":* ]]  ; then

			# Remove all occurrences from PATH variable
			while [[ ":${PATH}:" == *:"${path}":* ]] ; do

				# Remove path from PATH variable
				if [[ "${arr_len}" -eq 1 ]]; then # If Path length is 1
					PATH=${PATH//"${path}"/} # delete instance
				else
					PATH=${PATH//":${path}:"/":"} # delete any instances in the middle
					PATH=${PATH/#"${path}:"/} # delete any instance at the beginning
					PATH=${PATH/%":${path}"/} # delete any instance in the at the end
				fi
			done

			# Add path to the end
			PATH="${PATH:+${PATH}:}${path}"
			path_changed=true
		fi
	done

	# Export PATH
	if [[ "$path_changed" = true ]]; then
		export PATH
	fi
}

function _ros_conda_path_fix_inside() {
	# This function makes sure the anaconda bin and condabin folders
	# are earlier on the path than the /usr/bin, /bin and
	# /opt/ros/<ROSVERSION>/bin when inside an anaconda environment.

	# Create local variables
	local path_changed=false

	# Split PATH into array and get path length
	local defaultIFS="$IFS"; IFS=$' \t\n'; local path_array=(${PATH//:/ }); IFS="$defaultIFS"
	local arr_len="${#path_array[@]}"

	# # Make sure the Conda bin path is present on the PATH
	# # NOTE: Done since sourcing a ROS setup.bash removes the Conda bin path
	# if [[ "$CONDA_DEFAULT_ENV" == "base" || "$CONDA_DEFAULT_ENV" == "root" ]]; then # If in base

	# 	# Retrieve conda bin path
	# 	local _conda_env_bin_path="${ROS_CONDA_CONDA_PATH}/bin"

	# 	# Add bin path to PATH
	# 	PATH="${_conda_env_bin_path}${PATH:+:${PATH}}"
	# elif [[ -z "${CONDA_DEFAULT_ENV}" ]]; then # Not in conda environment
	# 	return 1 # Return with error code
	# else # Not in base

	# 	# Retrieve conda bin path
	# 	local _conda_env_bin_path="${ROS_CONDA_CONDA_PATH}/envs/${CONDA_DEFAULT_ENV}/bin"

	# 	# Add bin path to PATH
	# 	PATH="${_conda_env_bin_path}${PATH:+:${PATH}}"
	# fi

	# Make sure the Conda paths are at the beginning of the PATH variable
	ros_conda_path_array=(
		"${ROS_CONDA_CONDA_PATH}/condabin"
		"${ROS_CONDA_CONDA_PATH}/bin"
		"${ROS_CONDA_CONDA_PATH}/envs/${CONDA_DEFAULT_ENV}/bin"
	)
	for path in "${ros_conda_path_array[@]}"; do
		if [[ ":${PATH}:" == *:"${path}":* ]]  ; then

			# Remove all occurrences from PATH variable
			while [[ ":${PATH}:" == *:"${path}":* ]] ; do

				# Remove path from PATH variable
				if [[ "${arr_len}" -eq 1 ]]; then # If Path length is 1
					PATH=${PATH//"${path}"/} # delete instance
				else
					PATH=${PATH//":${path}:"/":"} # delete any instances in the middle
					PATH=${PATH/#"${path}:"/} # delete any instance at the beginning
					PATH=${PATH/%":${path}"/} # delete any instance in the at the end
				fi
			done

			# Prepend to PATH variable
			PATH="${path}${PATH:+:${PATH}}"
			path_changed=true
		fi
	done

	# Export PATH
	if [[ "$path_changed" = true ]]; then
		export PATH
	fi
}

function _ros_conda_pythonpath_fix_outside() {
	# This function makes sure that the ROS python dist-packages path
	# IS present on the PYTHONPATH when inside a Conda environment.

	# Create local variables
	local path_changed=false

	# Restore ROS python paths if they are not yet found on the PYTHONPATH
	for ros_python_path in "${ROS_CONDA_ROS_PYTHONPATH_BACKUP[@]}"; do
		if [[ -d "$ros_python_path" ]]; then
			if [[ ":$PYTHONPATH:" != *":${ros_python_path}:"* ]]; then

				# Prepend to PYTHONPATH variable
				PYTHONPATH="$ros_python_path${PYTHONPATH:+:${PYTHONPATH}}"
				path_changed=true
			fi
		fi
	done

	# Export PYTHONPATH
	if [[ "$path_changed" = true ]]; then

		# Export PYTHONPATH
		export PYTHONPATH
	fi
}

function _ros_conda_pythonpath_fix_inside() {
	# This function makes sure that the ROS python dist-packages path
	# is NOT present on the PYTHONPATH when inside a Conda environment.

	# Create local variables
	local path_changed=false
	local new_pythonpath_array=()

	# Split PYTHONPATH or PYTHONPATH into array
	local defaultIFS="$IFS"; IFS=$' \t\n'; local pythonpath_array=(${PYTHONPATH//:/ }); IFS="$defaultIFS"

	# Loop through the paths and retrieve the python paths
	for path in "${pythonpath_array[@]}"; do

		# Test if path is ros path
		if [[ "$path" == "/opt/ros/"*"/dist-packages" ]]; then

			# Add to ROS_PYTHONPATH_BACKUP array
			ROS_CONDA_ROS_PYTHONPATH_BACKUP+=("${path}")
			path_changed=true
		else

			# Pass to new PYTHONPATH array
			new_pythonpath_array+=("${path}")
		fi
	done

	# Export PYTHONPATH
	if [[ "$path_changed" = true ]]; then

		# Convert new PYTHONPATH back to : delimited string
		PYTHONPATH=$(IFS=$':'; echo "${new_pythonpath_array[*]}") # Converting bash array back into a delimited string

		# Export PYTHONPATH
		export PYTHONPATH
	fi
}

function _ros_conda_is_conda_env() {
	# This function checks if a Conda environment exists
	# it returns 0 if it does and 1 if it does not.

	# Try to activate conda environment in subshell (Faster than conda info --envs or conda envs --list)
	if [[ ("$ROS_CONDA_CONDA_VERSION" > 4.4.0 || "$ROS_CONDA_CONDA_VERSION" = 4.4.0) ]]; then
		retval="$(\conda activate $1 2>&1 > /dev/null)"
	else
		retval="$(\source activate $1 2>&1 > /dev/null)"
	fi

	# Check if environment existed
	if [[ "$retval" != *"Could not find conda environment"* ]]; then
		local retval="true" # Enviroment exists
	else
		local retval="false"  # Enviroment exists
	fi

	# Return result
	echo "$retval"
}

function _ros_conda_init() {
	# This function installs the packages that are needed to enable
	# ROS to work from within a Conda environment.

	# Get Conda environment name and path
	if [[ "$1" == "" ]]; then

		# If environment is active initialize that environment otherwise initialize base
		if  [[ ! -z "$CONDA_DEFAULT_ENV" ]]; then

			# Test if in base environment
			if [[ "$CONDA_DEFAULT_ENV" == "base" ]]; then
				local _conda_env_name="base"
				local _conda_env_path="$ROS_CONDA_CONDA_PATH"
			elif [[ "$CONDA_DEFAULT_ENV" == "root" ]]; then
				local _conda_env_name="root"
				local _conda_env_path="$ROS_CONDA_CONDA_PATH"
			else
				# Retrieve Conda env name
				local _conda_env_name="$CONDA_DEFAULT_ENV"

				# Retrieve Conda env path
				local _conda_env_path="${ROS_CONDA_CONDA_PATH}/envs/${_conda_env_name}"
			fi
		else

			# Check which conda version is used and assign the right name
			if [[ ("$ROS_CONDA_CONDA_VERSION" > 4.4.0 || "$ROS_CONDA_CONDA_VERSION" = 4.4.0) ]]; then

				# Retrieve Conda environment path
				local _conda_env_name="base"
				local _conda_env_path="$ROS_CONDA_CONDA_PATH"
			else
				# Retrieve Conda environment path
				local _conda_env_name="root"
				local _conda_env_path="$ROS_CONDA_CONDA_PATH"
			fi
		fi
	elif [[ "$1" == "base" ]]; then

		# Retrieve Conda environment path
		local _conda_env_name="base"
		local _conda_env_path="$ROS_CONDA_CONDA_PATH"
	elif [[ "$1" == "root" ]]; then

		# Retrieve Conda environment path
		local _conda_env_name="root"
		local _conda_env_path="$ROS_CONDA_CONDA_PATH"
	else

		# Retrieve Conda environment path
		local _conda_env_name="$1"
		local _conda_env_path="${ROS_CONDA_CONDA_PATH}/envs/${_conda_env_name}"
	fi

	# Install ROS Conda python dependencies if they are not yet installed
	if [[ ! "${#ROS_CONDA_DEPS[@]}" -eq 0 ]]; then
		for dep in "${ROS_CONDA_DEPS[@]}"; do
			if [[ "$(\conda list -n $_conda_env_name | grep -w $dep | grep -P '(?<!-)'$dep'(?!-)' | awk '{ print $1 }')" != "$dep" ]]; then
				echo "Installing conda package: $dep"
				\conda install -n "$_conda_env_name" --yes "${dep}"
			else
				echo "Conda package requirement already satisfied: $dep"
			fi
		done
	fi

	# Install if ROS Conda forge python dependencies if they are not yet installed
	if [[ ! "${#ROS_CONDA_FORGE_DEPS[@]}" -eq 0 ]]; then
		for dep in "${ROS_CONDA_FORGE_DEPS[@]}"; do
			if [[ "$(\conda list -n $_conda_env_name | grep -w $dep | grep -P '(?<!-)'$dep'(?!-)' | awk '{ print $1 }')" != "$dep" ]]; then
				echo "Installing conda package: $dep"
				\conda install -n "$_conda_env_name" --channel conda-forge --yes "${dep}"
			else
				echo "Conda package requirement already satisfied: $dep"
			fi
		done
	fi

	# Get pip install locations
	if [[ -z "$(find ${_conda_env_path}/bin/ -iname pip)" ]]; then

		# Install pip if not installed already
		echo "Installing conda package: pip"
		\conda install --yes "pip"
		local _env_pip_path="$(find ${_conda_env_path}/bin/ -iname pip)"

	else
		local _env_pip_path="$(find ${_conda_env_path}/bin/ -iname pip)"
	fi

	# Install ROS pip python dependencies if they are not yet installed
	if [[ ! "${#ROS_CONDA_PIP_DEPS[@]}" -eq 0 ]]; then
		for dep in "${ROS_CONDA_PIP_DEPS[@]}"; do
			if [[ "$($_env_pip_path list | grep -w $dep | grep -P '(?<!-)'$dep'(?!-)' | awk '{ print $1 }')" != "$dep" ]]; then
				echo "Installing pip package: $dep"
				"$_env_pip_path" install "${dep}"
			else
				echo "Pip package requirement already satisfied: $dep"
			fi
		done
	fi

	# Set CONDA_INIT environmental variable to true
	if [[ ! -f "$_conda_env_path/etc/conda/activate.d/env_vars.sh" ]]; then # Generate env vars activation file folder
		mkdir -p "$_conda_env_path/etc/conda/activate.d"
		cat <<-EOF >"$_conda_env_path/etc/conda/activate.d/env_vars.sh"
			#!/bin/sh

			## ROS_CONDA wrapper ENV variables
			# Created on $(date)
			export ROS_CONDA=TRUE
		EOF
	elif ! grep -q "ROS_CONDA=" "$_conda_env_path/etc/conda/activate.d/env_vars.sh"; then
		cat <<-EOF >>"$_conda_env_path/etc/conda/activate.d/env_vars.sh"

			## ROS_CONDA wrapper ENV variables
			# Created on $(date)
			export ROS_CONDA=TRUE
		EOF
	else
		sed -i -e 's/ROS_CONDA=FALSE/ROS_CONDA=TRUE/g' "$_conda_env_path/etc/conda/activate.d/env_vars.sh"
	fi

	# Create ROS environmental variable unset file if it does not exist
	if [ ! -f "$_conda_env_path/etc/conda/deactivate.d/env_vars.sh" ]; then # Generate env vars deactivation file folder
		mkdir -p "$_conda_env_path/etc/conda/deactivate.d"
		cat <<-EOF >"$_conda_env_path/etc/conda/deactivate.d/env_vars.sh"
			#!/bin/sh

			## ROS_CONDA wrapper ENV variables
			# Created on $(date)
			unset ROS_CONDA
		EOF
	elif ! grep -q "unset ROS_CONDA" "$_conda_env_path/etc/conda/deactivate.d/env_vars.sh"; then
		cat <<-EOF >>"$_conda_env_path/etc/conda/deactivate.d/env_vars.sh"

			## ROS_CONDA wrapper ENV variables
			# Created on $(date)
			unset ROS_CONDA
		EOF
	fi
}

function _ros_conda_deinit() {
	# This function removes the packages that are needed to enable
	# ROS to work from within a Conda environment.

	# Get Conda environment name and path
	if [[ "$1" == "" ]]; then

		# If environment is active initialize that environment otherwise initialize base
		if  [[ ! -z "$CONDA_DEFAULT_ENV" ]]; then

			# Test if in base environment
			if [[ "$CONDA_DEFAULT_ENV" == "base" ]]; then
				local _conda_env_name="base"
				local _conda_env_path="$ROS_CONDA_CONDA_PATH"
			elif [[ "$CONDA_DEFAULT_ENV" == "root" ]]; then
				local _conda_env_name="root"
				local _conda_env_path="$ROS_CONDA_CONDA_PATH"
			else
				# Retrieve Conda env name
				local _conda_env_name="$CONDA_DEFAULT_ENV"

				# Retrieve Conda env path
				local _conda_env_path="${ROS_CONDA_CONDA_PATH}/envs/${_conda_env_name}"
			fi
		else

			# Check which conda version is used and assign the right name
			if [[ ("$ROS_CONDA_CONDA_VERSION" > 4.4.0 || "$ROS_CONDA_CONDA_VERSION" = 4.4.0) ]]; then

				# Retrieve Conda environment path
				local _conda_env_name="base"
				local _conda_env_path="$ROS_CONDA_CONDA_PATH"
			else
				# Retrieve Conda environment path
				local _conda_env_name="root"
				local _conda_env_path="$ROS_CONDA_CONDA_PATH"
			fi
		fi
	elif [[ "$1" == "base" ]]; then

		# Retrieve Conda environment path
		local _conda_env_name="base"
		local _conda_env_path="$ROS_CONDA_CONDA_PATH"
	elif [[ "$1" == "root" ]]; then

		# Retrieve Conda environment path
		local _conda_env_name="root"
		local _conda_env_path="$ROS_CONDA_CONDA_PATH"
	else

		# Retrieve Conda environment path
		local _conda_env_name="$1"
		local _conda_env_path="${ROS_CONDA_CONDA_PATH}/envs/${_conda_env_name}"
	fi

	# Remove ROS Conda python dependencies if they are installed
	if [[ ! "${#ROS_CONDA_DEPS[@]}" -eq 0 ]]; then
		for dep in "${ROS_CONDA_DEPS[@]}"; do
			if [[ ! "$(\conda list -n $_conda_env_name | grep -w $dep | grep -P '(?<!-)'$dep'(?!-)' | awk '{ print $1 }')" != "$dep" ]]; then
				echo "Removing conda package: $dep"
				\conda remove -n "$_conda_env_name" --yes "${dep}"
			else
				echo "Conda package requirement already removed: $dep"
			fi
		done
	fi

	# Remove ROS Conda Forge python dependencies if they are installed
	if [[ ! "${#ROS_CONDA_FORGE_DEPS[@]}" -eq 0 ]]; then
		for dep in "${ROS_CONDA_FORGE_DEPS[@]}"; do
			if [[ ! "$(\conda list -n $_conda_env_name | grep -w $dep | grep -P '(?<!-)'$dep'(?!-)' | awk '{ print $1 }')" != "$dep" ]]; then
				echo "Removing conda package: $dep"
				\conda remove -n "$_conda_env_name" --channel conda-forge --yes "${dep}"
			else
				echo "Conda package requirement already removed: $dep"
			fi
		done
	fi

	# Get pip install locations
	if [[ -z "$(find ${_conda_env_path}/bin/ -iname pip)" ]]; then

		# Install pip if not installed already
		echo "Installing conda package: pip"
		\conda install --yes "pip"
		local _env_pip_path="$(find ${_conda_env_path}/bin/ -iname pip)"
	else
		local _env_pip_path="$(find ${_conda_env_path}/bin/ -iname pip)"
	fi

	# Remove ROS pip python dependencies
	if [[ ! "${#ROS_CONDA_PIP_DEPS[@]}" -eq 0 ]]; then
		for dep in "${ROS_CONDA_PIP_DEPS[@]}"; do
			if [[ ! "$($_env_pip_path list | grep -w $dep | grep -P '(?<!-)'$dep'(?!-)' | awk '{ print $1 }')" != "$dep" ]]; then
				echo "Removing pip package: $dep"
				"$_env_pip_path" uninstall --yes "$dep"
			else
				echo "Pip package already removed: $dep"
			fi
		done
	fi

	# Set CONDA_INIT environmental variable to true
	if [[ ! -f "$_conda_env_path/etc/conda/activate.d/env_vars.sh" ]]; then # Generate env vars activation file folder
		mkdir -p "$_conda_env_path/etc/conda/activate.d"
		cat <<-EOF >"$_conda_env_path/etc/conda/activate.d/env_vars.sh"
			#!/bin/sh

			## ROS_CONDA wrapper ENV variables
			# Created on $(date)
			export ROS_CONDA=FALSE
		EOF
	elif ! grep -q "ROS_CONDA=" "$_conda_env_path/etc/conda/activate.d/env_vars.sh"; then
		cat <<-EOF >>"$_conda_env_path/etc/conda/activate.d/env_vars.sh"

			## ROS_CONDA wrapper ENV variables
			# Created on $(date)
			export ROS_CONDA=FALSE
		EOF
	else
		sed -i -e 's/ROS_CONDA=TRUE/ROS_CONDA=FALSE/g' "$_conda_env_path/etc/conda/activate.d/env_vars.sh"
	fi

	# Create ROS environmental variable unset file if it does not exist
	if [[ ! -f "$_conda_env_path/etc/conda/deactivate.d/env_vars.sh" ]]; then # Generate env vars deactivation file folder
		mkdir -p "$_conda_env_path/etc/conda/deactivate.d"
		cat <<-EOF >"$_conda_env_path/etc/conda/deactivate.d/env_vars.sh"
			#!/bin/sh

			## ROS_CONDA wrapper ENV variables
			# Created on $(date)
			unset ROS_CONDA
		EOF
	elif ! grep -q "unset ROS_CONDA" "$_conda_env_path/etc/conda/deactivate.d/env_vars.sh"; then
		cat <<-EOF >>"$_conda_env_path/etc/conda/deactivate.d/env_vars.sh"

			## ROS_CONDA wrapper ENV variables
			# Created on $(date)
			unset ROS_CONDA
		EOF
	fi
}

###############################################
## ros_conda_wrapper main wrapper functions ###
###############################################
function _ros_conda_wrapper() {
	# This function serves a wrapper around the original Conda command. It is used
	# for Conda versions > 4.4.
	if [[ "$1" == "activate" && "$ROS_CONDA_WRAPPER_ACTIVE" == "true" && ("$ROS_CONDA_CONDA_VERSION" > 4.4.0 || "$ROS_CONDA_CONDA_VERSION" = 4.4.0) ]]; then # Warp Conda deactivate command

		# Set error variable
		local had_error=false

		# Apply path modifications if environment exists
		_ros_conda_path_fix_inside

		# Make sure the activation Conda command is executed
		\conda "$@" || had_error=true

		# Restore path if source command failed
		if [[ "$had_error" == true ]]; then
			if [[ -z "$CONDA_DEFAULT_ENV" ]]; then

				# Fix PATH and PYTHONPATH
				_ros_conda_path_fix_outside
				_ros_conda_pythonpath_fix_outside
			fi
		else
			# Fix PATH and PYTHONPATH
			_ros_conda_path_fix_inside
			_ros_conda_pythonpath_fix_inside
		fi

	elif [[ "$1" == "deactivate" && "$ROS_CONDA_WRAPPER_ACTIVE" == "true" && ("$ROS_CONDA_CONDA_VERSION" > 4.4.0 || "$ROS_CONDA_CONDA_VERSION" = 4.4.0) ]]; then # Warp Conda deactivate command

		# Make sure the deactivation Conda command is executed
		\conda "$@"

		# Fix PATH and PYTHONPATH
		if [[ ! -z "$CONDA_DEFAULT_ENV" ]]; then # If still inside Conda environment

			# Fix PATH and PYTHONPATH
			_ros_conda_path_fix_inside
			_ros_conda_pythonpath_fix_inside

		elif [[ -z "$CONDA_DEFAULT_ENV" ]]; then

			# # Fix PATH and PYTHONPATH
			_ros_conda_path_fix_outside
			_ros_conda_pythonpath_fix_outside
		fi

	elif [[ "$1" == "--ros-wrapper" ]]; then # Add ROS Conda wrapper cli

		# ROS Conda wrapper commands
		if [[ "$2" == "activate" ]]; then

			# Print the result message
			if $ROS_CONDA_WRAPPER_ACTIVE; then
				echo "Conda wrapper already active."
			else
				echo "Activated conda wrapper. "
			fi

			# Set ROS_CONDA_WRAPPER_ACTIVE environmental variable
			export ROS_CONDA_WRAPPER_ACTIVE=true

			# Save values to config file
			_ros_conda_save_config_vars
		elif [[ "$2" == "deactivate" ]]; then

			# Print the result message
			if ! $ROS_CONDA_WRAPPER_ACTIVE; then
				echo "Conda wrapper already deactivated."
			else
				echo "Deactivated conda wrapper. "
			fi

			# Set ROS_CONDA_WRAPPER_ACTIVE environmental variable
			export ROS_CONDA_WRAPPER_ACTIVE=false

			# Save values to config file
			_ros_conda_save_config_vars
		elif [[ "$2" == "init" ]]; then # Initialize BASE Conda environment to work with ROS

			# Get Conda environment name
			if [[ "$3" == "" ]]; then
				if  [[ ! -z "$CONDA_DEFAULT_ENV" ]]; then

					# Test if in base environment
					if [[ "$CONDA_DEFAULT_ENV" == "base" ]]; then
						local _conda_env_name="base"
					elif [[ "$CONDA_DEFAULT_ENV" == "root" ]]; then
						local _conda_env_name="root"
					else
						# Retrieve Conda env name
						local _conda_env_name="$CONDA_DEFAULT_ENV"
					fi
				else

					# Check which conda version is used and assign the right name
					if [[ ("$ROS_CONDA_CONDA_VERSION" > 4.4.0 || "$ROS_CONDA_CONDA_VERSION" = 4.4.0) ]]; then

						# Retrieve Conda environment path
						local _conda_env_name="base"
					else
						# Retrieve Conda environment path
						local _conda_env_name="root"
					fi
				fi
			elif [[ "$1" == "base" ]]; then

				# Retrieve Conda environment path
				local _conda_env_name="base"
			elif [[ "$1" == "root" ]]; then

				# Retrieve Conda environment path
				local _conda_env_name="root"
			else

				# Retrieve Conda environment path
				local _conda_env_name="$3"
			fi

			# Check whether environment that user specified is valid
			if [[ "$(_ros_conda_is_conda_env $_conda_env_name)" == "false" ]]; then
				echo "Could not find Conda environment: $_conda_env_name" 1>&2
				echo "You can list all discoverable environments with \`conda info --envs\`."
				return 1
			fi

			# Ask user if he/she wants to continue with the initialization
			while true; do
				read -r -p "You are about to initialize your \"$_conda_env_name\" Conda environment to work with ROS. Are you sure? [y/n] " response
				case "$response" in
				[yY][eE][sS] | [yY])
					_ros_conda_init "$3"
					break
					;;
				[nN][oO] | [nN])
					echo "Canceling Conda ROS initialization."
					break
					;;
				*)
					echo "Please enter a valid response."
					;;
				esac
			done

		elif [[ "$2" == "deinit" ]]; then # Deinitialize main environment ros_conda wrapper

			# Get Conda environment name
			if [[ "$3" == "" ]]; then
				if  [[ ! -z "$CONDA_DEFAULT_ENV" ]]; then

					# Test if in base environment
					if [[ "$CONDA_DEFAULT_ENV" == "base" ]]; then
						local _conda_env_name="base"
					elif [[ "$CONDA_DEFAULT_ENV" == "root" ]]; then
						local _conda_env_name="root"
					else
						# Retrieve Conda env name
						local _conda_env_name="$CONDA_DEFAULT_ENV"
					fi
				else

					# Check which conda version is used and assign the right name
					if [[ ("$ROS_CONDA_CONDA_VERSION" > 4.4.0 || "$ROS_CONDA_CONDA_VERSION" = 4.4.0) ]]; then

						# Retrieve Conda environment path
						local _conda_env_name="base"
					else
						# Retrieve Conda environment path
						local _conda_env_name="root"
					fi
				fi
			elif [[ "$1" == "base" ]]; then

				# Retrieve Conda environment path
				local _conda_env_name="base"
			elif [[ "$1" == "root" ]]; then

				# Retrieve Conda environment path
				local _conda_env_name="root"
			else

				# Retrieve Conda environment path
				local _conda_env_name="$3"
			fi

			# Check whether environment that user specified is valid
			if [[ "$(_ros_conda_is_conda_env $_conda_env_name)" == "false" ]]; then
				echo "Could not find Conda environment: $_conda_env_name" 1>&2
				echo "You can list all discoverable environments with \`conda info --envs\`."
				return 1
			fi

			# Ask user if he/she wants to continue with the initialization
			while true; do
				read -r -p "You are about to deinitialize your \"$_conda_env_name\" Conda environment to work with ROS. Are you sure? [y/n] " response
				case "$response" in
				[yY][eE][sS] | [yY])
					_ros_conda_deinit "$3"
					break
					;;
				[nN][oO] | [nN])
					echo "Canceling Conda ROS deinitialization."
					break
					;;
				*)
					echo "Please enter a valid response."
					;;
				esac
			done

		elif [[ "$2" == "-s" || "$2" == "--show-settings" ]]; then

			# Print current settings
			cat <<- EOM
				Wrapper active: $ROS_CONDA_WRAPPER_ACTIVE
				Wrapper error: $ROS_CONDA_WRAPPER_ERROR
			EOM
		elif [[ "$2" == "-h" || "$2" == "--help" ]]; then

			# Print help menu
			_ros_conda_usage

		elif [[ "$2" == '-v' || "$2" == "--version" ]]; then
			echo "v$ROS_CONDA_WRAPPER_VERSION"
		else

			# Print help menu
			_ros_conda_usage
		fi
	else # Make sure other Conda commands are executed
		\conda "$@" # Quotes since bash strips the outer quotes
	fi
}

function _ros_conda_source_wrapper() {
	# This function serves a wrapper around
	# the original Conda command. This alias
	# is used for Conda v < 4.4.

	if [[ "$1" == "activate" && "$ROS_CONDA_WRAPPER_ACTIVE" == "true"  && "$ROS_CONDA_CONDA_VERSION" < 4.4 ]]; then # Warp Conda deactivate command

		# Set error variable
		local had_error=false

		# Apply path modifications if environment exists
		_ros_conda_path_fix_inside

		# Make sure the activation Conda command is executed
		if [[ "$#" == 1 ]]; then

			# Try to activate environment using root
			# NOTE: This was done since `\source activate` from within a
			# script gave a strange error.
			\source activate "root" || had_error=true
		else
			\source "$@" || had_error=true
		fi

		# Restore path if source command failed
		if [[ "$had_error" == true ]]; then
			if [[ -z "$CONDA_DEFAULT_ENV" && "$ROS_CONDA_WRAPPER_ACTIVE" == "true" ]]; then

				# Fix PATH and PYTHONPATH
				_ros_conda_path_fix_outside
				_ros_conda_pythonpath_fix_outside
			fi
		else
			# Fix PATH and PYTHONPATH
			_ros_conda_path_fix_inside
			_ros_conda_pythonpath_fix_inside
		fi


	elif [[ "$1" == "deactivate" && "$ROS_CONDA_WRAPPER_ACTIVE" == "true"  && "$ROS_CONDA_CONDA_VERSION" < 4.4 ]]; then # Warp Conda deactivate command

		# Make sure the deactivation Conda command is executed
		\source "$@"

		# Fix PATH and PYTHONPATH
		if [[ ! -z "$CONDA_DEFAULT_ENV" ]]; then # If still inside Conda environment

			# Fix PATH and PYTHONPATH
			_ros_conda_path_fix_inside
			_ros_conda_pythonpath_fix_inside

		elif [[ -z "$CONDA_DEFAULT_ENV" ]]; then

			# # Fix PATH and PYTHONPATH
			_ros_conda_path_fix_outside
			_ros_conda_pythonpath_fix_outside
		fi

	elif [[ "$1" == "/opt/ros"*"/setup.bash" && "$ROS_CONDA_WRAPPER_ACTIVE" == "true" ]]; then

		# Create error check variable
		local had_error=false

		# Execute source command
		\source "$@" || had_error=true

		# Fix paths if source was successful
		if [[ "$had_error" == false ]]; then

			# Check if your inside or outside an anaconda environment
			if [[ ! -z "$CONDA_DEFAULT_ENV" ]]; then # Inside environment

				# Fix PATH and PYTHONPATH
				_ros_conda_path_fix_inside
				_ros_conda_pythonpath_fix_inside
			else

				# Fix PATH and PYTHONPATH
				_ros_conda_path_fix_outside
				_ros_conda_pythonpath_fix_outside
			fi
		fi
	elif [[ "$1" == *"devel/setup.bash" && "$ROS_CONDA_WRAPPER_ACTIVE" == "true" ]]; then

		# Execute source command
		local had_error=false
		\source "$@" || had_error=true

		# Fix paths if source was successful
		if [[ "$had_error" == false ]]; then

			# Get full path
			local sourced_path="$1"
			local sourced_path_absolute="$(cd $(dirname ${sourced_path}) 2>/dev/null && pwd -P)/$(basename ${sourced_path})"
			if [[ -e "$sourced_path_absolute" ]]; then

				# Get main catkin_ws path
				local catkin_ws_path="$(dirname $(dirname ${sourced_path_absolute}))"

				# Check if sourced file was inside catkin_ws
				if [[ -e "${catkin_ws_path}/.catkin_workspace" || -e "${catkin_ws_path}/.catkin_tools" ]]; then

					# Check if your inside or outside an anaconda environment
					if [[ ! -z "$CONDA_DEFAULT_ENV" ]]; then # Inside environment

						# Fix PATH and PYTHONPATH
						_ros_conda_path_fix_inside
						_ros_conda_pythonpath_fix_inside
					else

						# Fix PATH and PYTHONPATH
						_ros_conda_path_fix_outside
						_ros_conda_pythonpath_fix_outside
					fi
				fi
			fi
		fi
	else # Make sure other Conda commands are executed

		# Make sure the activation Conda command is executed
		if [[ "$1" == "activate" ]]; then
			if [[ "$#" == 1 && "$ROS_CONDA_CONDA_VERSION" < 4.4 ]]; then
				# Try to activate environment using root
				# NOTE: This was done since `\source activate` from within a
				# script gave a strange error.
				\source activate "root"
			else
				\source "$@"
			fi
		else
			\source "$@"
		fi
	fi
}

function _ros_conda_dot_source_wrapper() {
	# This function serves a wrapper around
	# the dot source command (.) to make sure that
	# the path and the PYTHONPATH stay fixed when
	# ROS or a catkin workspace is sourced.

	if [[ "$1" == "/opt/ros"*"/setup.bash" && "$ROS_CONDA_WRAPPER_ACTIVE" == "true" ]]; then

		# Create error check variable
		local had_error=false

		# Execute source command
		\. "$@" || had_error=true

		# Fix paths if source was successful
		if [[ "$had_error" == false ]]; then

			# Check if your inside or outside an anaconda environment
			if [[ ! -z "$CONDA_DEFAULT_ENV" ]]; then # Inside environment

				# Fix PATH and PYTHONPATH
				_ros_conda_path_fix_inside
				_ros_conda_pythonpath_fix_inside
			else

				# Fix PATH and PYTHONPATH
				_ros_conda_path_fix_outside
				_ros_conda_pythonpath_fix_outside
			fi
		fi
	elif [[ "$1" == *"devel/setup.bash"  && "$ROS_CONDA_WRAPPER_ACTIVE" == "true" ]]; then

		# Execute source command
		local had_error=false
		\. "$@" || had_error=true

		# Fix paths if source was successful
		if [[ "$had_error" == false ]]; then

			# Get full path
			local sourced_path="$1"
			local sourced_path_absolute="$(cd $(dirname ${sourced_path}) 2>/dev/null && pwd -P)/$(basename ${sourced_path})"
			if [[ -e "$sourced_path_absolute" ]]; then

				# Get main catkin_ws path
				local catkin_ws_path="$(dirname $(dirname ${sourced_path_absolute}))"

				# Check if sourced file was inside catkin_ws
				if [[ -e "${catkin_ws_path}/.catkin_workspace" || -e "${catkin_ws_path}/.catkin_tools" ]]; then

					# Check if your inside or outside an anaconda environment
					if [[ ! -z "$CONDA_DEFAULT_ENV" ]]; then # Inside environment

						# Fix PATH and PYTHONPATH
						_ros_conda_path_fix_inside
						_ros_conda_pythonpath_fix_inside
					else

						# Fix PATH and PYTHONPATH
						_ros_conda_path_fix_outside
						_ros_conda_pythonpath_fix_outside
					fi
				fi
			fi
		fi
	else # Make sure other Conda commands are executed
		\. "$@" # Quotes since bash strips the outer quotes
	fi
}

###############################################
## Setup ros_conda_wrapper aliases ############
###############################################

# Fix PATH variables create Conda wrapper aliases
_ros_conda_main() {

	# Retrieve Conda paths and version
	defaultIFS="$IFS"; IFS=$' \t\n'; paths_array=(${PATH//:/ }); IFS="$defaultIFS"
	for path in "${paths_array[@]}"; do

		# Retrieve Conda path
		if [[ "$path" == "/home/"*"/"*"conda"*"/condabin" ]];then

			# Retrieve CONDA_PATH
			# NOTE: I had to add the ROS_CONDA prefix since
			# some versions of conda also use the CONDA_PATH variable.
			ROS_CONDA_CONDA_PATH=${path%"/condabin"}
			CONDA_CONDABIN_PATH=${ROS_CONDA_CONDA_PATH}"/condabin"
			CONDA_BIN_PATH=${ROS_CONDA_CONDA_PATH}"/bin"

		elif [[ "$path" == "/home/"*"/"*"conda"*"/bin" ]]; then

			# Retrieve CONDA_PATH
			ROS_CONDA_CONDA_PATH=${path%"/bin"}
			CONDA_CONDABIN_PATH=${ROS_CONDA_CONDA_PATH}"/condabin"
			CONDA_BIN_PATH=${ROS_CONDA_CONDA_PATH}"/bin"
		fi

		# Unset local variables
		unset paths_array
	done

	# Get conda path conda > v4.5.1
	if [[ ! -d "$ROS_CONDA_CONDA_PATH" ]]; then
		if [[ -v CONDA_PYTHON_EXE ]]; then
			CONDA_BIN_PATH="$(dirname "$CONDA_PYTHON_EXE")"
			ROS_CONDA_CONDA_PATH="$(dirname "$CONDA_BIN_PATH")"
			CONDA_CONDABIN_PATH=${ROS_CONDA_CONDA_PATH}"/condabin"
		fi
	fi

	# Check if a valid path was found
	if [[ -d "$ROS_CONDA_CONDA_PATH" ]]; then

		# Get Conda base site packages path
		CONDA_BASE_SITE_PACKAGES_PATH="$(find ${ROS_CONDA_CONDA_PATH}/lib -iname site-packages)"

		# Check Conda version
		CONDA_EXE="${CONDA_BIN_PATH}/conda"
		CONDABIN_EXE="${CONDABIN_EXE}/conda"
		if [[ -x "$CONDA_EXE" ]]; then
			ROS_CONDA_CONDA_VERSION="$($CONDA_EXE -V)"
			ROS_CONDA_CONDA_VERSION=${ROS_CONDA_CONDA_VERSION//[^0-9.]/}
		elif [[ -x "$CONDABIN_EXE" ]]; then
			ROS_CONDA_CONDA_VERSION="$($CONDABIN_EXE -V)"
			ROS_CONDA_CONDA_VERSION=${ROS_CONDA_CONDA_VERSION//[^0-9.]/}
		fi

		# Check if Conda command is available
		if [[ "$(LC_ALL=C type -t conda)" == "function" ]]; then # Check if function conda > v4.5.1
			ROS_CONDA_WRAPPER_ERROR=false
		elif [[ "$(LC_ALL=C type -t conda)" == "file" ]]; then # Check if file conda < v4.5.1
			if [[ -x "$(LC_ALL=C type -p conda)" ]]; then # Check if executable
				ROS_CONDA_WRAPPER_ERROR=false
			else
				# Display anaconda needs to be activated warning
				echo -e "${ORANGE_CC}WARNING:${NC_CC} It appears that anaconda was initiated but the conda command can not be" \
				"executed. Please make sure a valid anaconda path is present in your PATH and that the right permissions are set." 1>&2

				# Set Conda wrapper error variable
				ROS_CONDA_WRAPPER_ERROR=true
			fi
		else
			# Display anaconda needs to be activated warning
			echo -e "${ORANGE_CC}WARNING:${NC_CC} It appears that anaconda was not initiated before this wrapper was sourced." \
			"Please make sure anaconda is initiated in your .bashrc file before running the ros_conda_wrapper." 1>&2

			# Set Conda wrapper error variable
			ROS_CONDA_WRAPPER_ERROR=true
		fi
	else

		# Display anaconda needs to be activated warning
		echo -e "${ORANGE_CC}WARNING:${NC_CC} It appears that anaconda was not initiated before this wrapper was sourced." \
		"Please make sure anaconda is initiated in your .bashrc file before running the ros_conda_wrapper." 1>&2

		# Set Conda wrapper error variable
		ROS_CONDA_WRAPPER_ERROR=true
	fi

	# Activate ROS CO
	if [[ "$ROS_CONDA_WRAPPER_ERROR" == false ]]; then

		# Load configuration values
		_ros_conda_load_config_vars

		# Fix PATH and PYTHONPATH
		if [[ ! -z "$CONDA_DEFAULT_ENV" && "$ROS_CONDA_WRAPPER_ACTIVE" == "true" ]]; then # Inside environment

			#Fix PATH and PYTHONPATH
			_ros_conda_path_fix_inside
			_ros_conda_pythonpath_fix_inside

		elif [[ -z "$CONDA_DEFAULT_ENV" && "$ROS_CONDA_WRAPPER_ACTIVE" == "true" ]]; then

			# Fix PATH and PYTHONPATH
			_ros_conda_path_fix_outside
			_ros_conda_pythonpath_fix_outside
		fi

		# Set aliases
		alias conda="_ros_conda_wrapper"
		alias source="_ros_conda_source_wrapper"
		alias .="_ros_conda_dot_source_wrapper"
	fi
}

# Execute _ros_conda_main function
_ros_conda_main "$@"
# _ros_conda_wrapper "$@"
unset -f _ros_conda_main 2> /dev/null