Skip to content

Instantly share code, notes, and snippets.

@denisxab

denisxab/.bashrc

Last active March 1, 2023 18:48
Show Gist options
  • Save denisxab/5c5032420b941ec692146544ca2fec57 to your computer and use it in GitHub Desktop.
Save denisxab/5c5032420b941ec692146544ca2fec57 to your computer and use it in GitHub Desktop.
Download ZIP
source_code.sh
Raw
.bashrc
source "~/source_code.sh"
Raw
source_code.sh
#!/bin/bash
######################################################################################
# Мои переменные окурежния
# Если не указн путь к Bashler то брем путь по умолчанию
if [[ -z $BASHLER_PATH ]]; then
export BASHLER_PATH="$HOME/bashler"
fi
# Путь к файлу автозапуска
if [[ -z $AUTORUN_BASHLER ]]; then
export AUTORUN_BASHLER="$HOME/.autorun_bashler"
fi
# Путь к найтрокам удаленного доступа
if [[ -z $BASHLER_REMOTE_PATH ]]; then
export BASHLER_REMOTE_PATH="$HOME/.bashler_remote"
fi
# Путь к Python модулям
export BASHLER_PATH_PY="$BASHLER_PATH/py"
# Путь к парсеру комадной строки
export BASHLER_PATH_PY_PYPARS="$BASHLER_PATH_PY/pypars.py"
######################################################################################
# Открывать файлы с указаным разширенем в указанной программе
alias {txt,md,conf,log}=micro
alias {js,py,cs,ts,html}=code
######################################################################################
#
# Глобальные Alias
#
# Алиасы для программ
alias configer="$DISK/MyProject/PycharmProjects/configer/venv/bin/python3.10 $DISK/MyProject/PycharmProjects/configer/configer/main.py"
alias gitclones="$DISK/MyProject/PycharmProjects/git_clons/venv/bin/python3.10 $DISK/MyProject/PycharmProjects/git_clons/git_clons/main.py"
alias pytots="$DISK/MyProject/python_to_ts_type/venv/bin/python3.11 $DISK/MyProject/python_to_ts_type/main.py"
alias showlogsmal="/home/denis/PycharmProjects/showlofsmal/showlogsmal.bin"
alias ~py=python3.11
alias pip="~py -m pip"
alias ~bpy="~py -m bpython"
alias syncthing="$DISK/AlienApp/aplication/other/Syncthing/syncthing-linux-amd64-v1.20.1/syncthing"
alias dbeaver="snap run dbeaver-ce"
alias templaer="~py -m templaer"
#
alias ..="cd .."
# замена ls на NNN
alias nnn='nnn -de'
######################################################################################
#!/bin/bash
# Git
alias gst="git status"
alias glog="git log"
alias gbra="git branch"
alias gcd="git checkout $1"
alias gmer="git merge $1"
# Разница между коммитами или ветками
alias gdif="git diff $1"
alias grst="git reset --hard"
gadd() {
# Создать комит всех изменений
date=$(date +\"%c\")
req="git add -A && git commit -m '$date - $1'"
echo $req
eval $req
}
gaddp() {
# Создать комит всех изменений и выполнить push
gadd $@
echo 'git push'
git push
}
garch() {
# Сделать архив текущей ветки
req="git archive --format zip --output $1.zip "
req+=$(git rev-parse --abbrev-ref HEAD)
echo $req
eval $req
}
grmh() {
# Удалить файл из отслеживания
res=`git rm --cached -r $1`
echo $res
eval $res
}
gitignore(){
template='''__pycache__
log
venv
/html
.vscode
/dist
'''
echo $template > '.gitignore'
}
gremot-up-token() {
# Обновить токен в URL
# $1 = Токен
git_url=$(git remote get-url origin)
new_token=$1
new_url=$(~py -c '''
import sys
import re
gir_url = sys.argv[1]
new_token = sys.argv[2]
res=new_token.join(re.search("(.+:).+(@.+)",gir_url).group(1,2))
print(res)
''' $git_url $new_token)
res="git remote set-url origin $new_url"
echo $res
eval $res
}
#!/bin/bash
###
# Формтирование и линтеры
###
# Убрать предупреждение E501,W505,C901,F401,W605 и игнорировать папку venv
alias flake8='~py -m flake8 --extend-ignore E501,W505,C901,F401,W605 --exclude venv'
alias isort='~py -m isort'
alias black='~py -m black'
# pep 8
pep() {
# Форматировать Python код
# $1 = путь к файлу или папки, если указана папка то тогда отформатируется вссе файлы в этой папке
# Форматирвоать отстпов
black $1
# Удалить неиспользуемые импорты
pimport $1
# Отсортировать Импроты
isort $1
}
# ppep8() {
# # Отформатировать python файл
# # $1 = путь к файлу или папки, если указана папка то тогда отформатируется вссе файлы в этой папке
# # Установить `pip install autopep8`
# if [[ -f $1 ]]; then
# ~py -m autopep8 --in-place --aggressive -v $1
# elif [[ -d $1 ]]; then
# ~py -m autopep8 --in-place --aggressive -v -r $1
# fi
# }
pimport() {
# Форматировать иморты, удалить не используемые импорты
# $1 = путь к файлу или папки, если указана папка то тогда отформатируется вссе файлы в этой папке
# Установить `pip install autoflake`
if [[ -f $1 ]]; then
~py -m autoflake --in-place --remove-unused-variables $1
elif [[ -d $1 ]]; then
~py -m autoflake --in-place --remove-unused-variables -r $1
fi
}
# PIP
# Установаить пакет
pipin() {
# Если актевировано окружение то установить пакет в него
res=""
if [[ -n $VIRTUAL_ENV ]]; then
res="$VIRTUAL_ENV/bin/python -m pip install $1"
else
res="~py -m pip install $1"
fi
echo $res
eval $res && ~py -c '''
import pathlib
import sys
import re
path_self = sys.argv[1]
package = sys.argv[2]
requirements = pathlib.Path(path_self) / "requirements.txt"
if requirements.exists():
if_exist = re.search(f"{package}[ \t><=!\n]", requirements.read_text())
if not if_exist:
with requirements.open("a") as f:
f.write(f"{package}\n")
else:
requirements.write_text(package)
''' $(pwd) $1
}
# Удалить пакет
piprm() {
# Если актевировано окружение то удляем пакет из него
res=""
if [[ -n $VIRTUAL_ENV ]]; then
res="$VIRTUAL_ENV/bin/python -m pip uninstall $1"
else
res="~py -m pip uninstall $1"
fi
echo $res
eval $res && ~py -c '''
import pathlib
import sys
import re
path_self = sys.argv[1]
package = sys.argv[2]
requirements = pathlib.Path(path_self) / "requirements.txt"
if requirements.exists():
rt = requirements.read_text()
rtn = re.sub(f"{package}[ \t><=!\n]","", rt)
requirements.write_text(rtn)
''' $(pwd) $1
}
# Обновить сам pip
pipup-self() {
# Обновить pip
~py -m pip install --upgrade pip
}
# Poetry
poetry-() {
res=""
if [[ -n $VIRTUAL_ENV ]]; then
res="$VIRTUAL_ENV/bin/python -m poetry $@"
else
res="~py -m poetry $@"
fi
echo $res
eval $res
}
poetry-req() {
# Создать файл requirements.txt
poetry export --dev --format requirements.txt --output requirements.txt
}
# Venv
# Создать окружение
pcvenv() {
if [[ -z $1 ]]; then
b_dirname='venv'
else
b_dirname=$1
fi
res="~py -m venv $b_dirname"
echo $res
eval $res
}
# Актевировать окружение
pavenv() {
if [[ -z $1 ]]; then
b_dirname='./venv/bin/activate'
else
b_dirname=$1
fi
res="source $b_dirname"
echo $res
eval $res
}
# Деактевировать окружение
pdvenv() {
deactivate
}
# Poetry
poetry_init() {
# Звгрузить poetry
pip install cachecontrol
pipupdate
pip install poetry
poetry install
}
# -------------------
phttpserver() {
# Запустить сервер п разадчи файлов
# $1 порт
~py -c '''
from http.server import HTTPServer, SimpleHTTPRequestHandler, test
import sys
class CORSRequestHandler (SimpleHTTPRequestHandler):
def end_headers(self):
# Для разрешения CROS.(Запросы от других url)
self.send_header("Access-Control-Allow-Origin", "*")
SimpleHTTPRequestHandler.end_headers(self)
test(
CORSRequestHandler,
HTTPServer,
port=int(sys.argv[1]) if len(sys.argv) > 1 else 8000,
)
''' $1
}
#!/bin/bash
# Find
-find() {
# find [ОткудаИскать...] -name "ЧтоИскать"
# `*` = Любой символ до и после
# -iname = Поиск БЕЗ учета регистра
# -name = Поиск С учетом регистра
# --not -name = Поиск НЕ совпадений шаблону
# -maxdepth Число = Максимальная глубина поиска
# -type d = Поиск только папок
# -type f = Поиск только файлов
# -perm 0664 = Поиск по разришению файлов
# -mtime Дней = Модифецированные столько дней назад
# -atime Дней = Открытые столько дней назад
# -not = НЕ
# -o = ИЛИ
find $@
}
-find-e() {
# Поиск всех файлов с указаным разширением
find . -name "*.$1"
}
-find-f() {
# Поиск файла или папки по указаному шаблоному имени
find . -iname "$1"
}
-find-tree() {
# Фильтрация вывода
# > шаблон_слово
tree -a -F | grep $@
}
-find-t() {
# Поиск текста в файлах по указаному шаблону
# $1 - Что искать
# $2 - Где искать
# $3 - Исключить пути из поиска
res='grep'
path_="$2"
if [[ -z $2 ]]; then
path_="."
fi
if [[ -n $3 ]]; then
res+=" --exclude-dir={$3}"
fi
res+=" -rnw '$path_' -e '$1'"
echo $res
eval $res
}
-find-chage-more() {
# Поиск файлов в директории `$1` которые изменялись более `$2` дней
# `$1` Путь к паке в которой искать
# `$2` Сколько дней назад изменялось, если нужно сегодня то укажите 0
# `$3` Во сколько директория можно углубляться, по умолчанию во все
day=$(expr $2 - 1)
if [[ $2 -eq 0 ]]; then
day=0
else
# 0 Изменялись сегодня
# +0 Изменялись вчера и далее
# +1 Изменялись позавчера и далее
day="+$day"
fi
maxdepth='-maxdepth'
if [[ -z $3 ]]; then
maxdepth=""
else
maxdepth="$maxdepth $3"
fi
# %TY-%Tm-%Td %TT %p\n
res="find $1 $maxdepth -mtime $day -printf '\033[92m%TY-%Tm-%Td %TT\033[0m\t\033[93m%p\033[0m\n' | sort -r"
echo $res
eval $res
}
#!/bin/bash
__read-line-file-return-bash-for() {
# Прочитать файл с переносами строк и вернуть bash массив
#
# Пример испоильзования
#
# list_text=`__read-line-file-return-bash-for sd`
# for x in `echo $das`
# do
# echo ") $x"
# done
echo $(~py -c "
import sys
name_file=sys.argv[1]
with open(name_file,'r') as _f:
data = _f.read()
res=''
for x in data.split():
res+='\"%s\" ' % x
print(res)
" $1)
}
__write-file() {
# Записать текст в файл
echo "$1" >$2
}
__pypars() {
# Парсить командную строку
#
# :Вот так вызывать:
#
# parms=$(__pypars $@)
# eval $parms
res=$(eval "~py $BASHLER_PATH_PY_PYPARS \"$@\"")
echo $res
}
#------------------
-uid(){
#
# Сгинироровать UUID в виде `x6nUxOD56_MAAA__`
#
# echo ${$(uuidgen -t)//-/}
echo $(~py -c '''
import base64
import random
import re
len_b=8
value = random.getrandbits(64)
by = value.to_bytes(len_b, byteorder="little")
b64 = base64.urlsafe_b64encode(by).decode("ascii")
print(re.sub(r"[\=\-]", "_", b64))
''')
}
#!/bin/bash
autorun-bashler() {
# Логика запуска программ
tmp_path="/tmp/autorun_bashler"
exists_tmp_path="$tmp_path/.run_autorun_bashler"
if [[ -d $tmp_path ]]; then
echo "Папка существует $tmp_path"
else
# Создаем католог в /tmp
mkdir $tmp_path
echo "Создана папка $tmp_path"
fi
if [[ -f $exists_tmp_path ]]; then
echo "Уже запущенно. Файл существует $exists_tmp_path"
else
if [[ -f $AUTORUN_BASHLER ]]; then
echo $AUTORUN_BASHLER
list_dir="$(~py -c '''
import json
from pathlib import Path
import os
p_AUTORUN_BASHLER = Path(os.environ["AUTORUN_BASHLER"])
r = json.loads(p_AUTORUN_BASHLER.read_text())
res = ""
for script in r:
res += f"{script}\n"
print(res)
''')"
IFS=$'\n'
for x in $(echo $list_dir); do
# Фоновый запуск
res="$x >/dev/null &"
echo $res
eval $res
done
touch $exists_tmp_path
else
echo "Путь не существует $AUTORUN_BASHLER"
fi
fi
}
autorun-bashler-force() {
# Принудтельно перезапустить программ
tmp_path="/tmp/autorun_bashler"
rm -rf $tmp_path
autorun-bashler
}
#!/bin/bash
-rsync-server() {
# Синхронезировать с сервером по SSH, если в ВЫХОДНОЙ(out) папке отличия, то удалить их
#
# $1 = localpath
# $2 = username@ip:pat
# -p = port
# -e папка_1 папка_... = Исключить папки или файлы из сихронизации
# -d = Удаляить файлы и папки в `out` если их нет в `in`
# rsync -azvh --progress ./firebird_book1 root@5.63.154.238:/home/ubuntu/test -e "ssh -p 22"
#
# Парсим командную строку
#
parms=$(__pypars $@)
echo $parms
eval $parms
#
# Исключение папок
#
exclud_folder=""
if [[ -n ${e[@]} ]]; then
for key in "${e[@]}"; do
exclud_folder="$exclud_folder --exclude=$key"
done
fi
#
# Порт
#
SSH_RES=""
if [[ -n $3 ]] && [[ ${3:0:2} != '-e' ]]; then
SSH_RES="-e \"ssh -p ${p[1]}\""
fi
#
# Нужно ли удалять файлы и папки в `out` если их нет в `in`
#
is_delete=""
if [[ ${_f[*]} =~ "d" ]]; then
is_delete='--delete'
fi
#
# Формируем и выполняем запрос
#
res="rsync -azvh --progress $is_delete ${_p[1]} ${_p[2]} $SSH_RES $exclud_folder"
echo $res
eval $res
}
-rsync-parse-conf() {
# Выполнить синхронизацию из `.bash_remote.json`
#
# $1 = ПроизвольноеИмяПодключения_RSYNC
#
res=$(~py -c '''
import pathlib
import sys
import json
path_to_remote_file = sys.argv[1]
name_connect_from_conf = sys.argv[2]
json_conf = json.loads(pathlib.Path(path_to_remote_file).read_text())
# Конфигурация Rsync
conf_rsync = json_conf["rsync"].get(name_connect_from_conf)
res = []
q = chr(34) # Знак двойных кавычек
if conf_rsync:
# Конфигурация SSH которая указана в Rsync
conf_ssh = json_conf["ssh"].get(conf_rsync["ssh"])
if conf_ssh:
port = conf_ssh["port"]
user = conf_ssh["user"]
host = conf_ssh["host"]
for _path in conf_rsync["sync_dir"]:
# Формируем команды
res.append(
"-rsync-server {path_in} {user}@{host}:{path_out} -p {port} {d} {e}".format(
path_in=_path["in"],
user=user,
host=host,
path_out=_path["out"],
port=port,
d="-d_" if _path.get("d") else "",
e="-e {q}{f}{q}".format(q=q, f=f"{q} {q}".join(
_path["e"])
) if _path.get("e") else ""
)
)
else:
raise KeyError(
f"Не найдено SSH подключение по имени - {name_connect_from_conf}"
)
# Выводим команды
print(";\n".join(res))
''' $BASHLER_REMOTE_PATH $1)
echo $res
eval $res
}
#################
# -rsync-local-folder() {
# # Синхронизировать локальные папки
# # > откуда куда
# # -e папка_1 папка_... = Исключить папки или файлы из сихронизации
# # --dry-run = Показать какие файлы будут сихронезированы без выполени программы
# exclud_folder=$(__rsync-exlude-folder $@)
# res="rsync -azvh --progress $1 $2 $exclud_folder"
# echo $res
# eval $res
# }
# -rsync-delete-local-folder() {
# # Синхронизировать папки, если в ВЫХОДНОЙ(out) папке отличия, то удалить их
# # -e папка_1 папка_... = Исключить папки или файлы из сихронизации
# exclud_folder=$(__rsync-exlude-folder $@)
# res="rsync -azvh --progress --delete $1 $2 $exclud_folder"
# echo $res
# eval $res
# }
# -rsync-server-folder() {
# # Синхронезировать с сервером по SSH
# # > port username@ip:path localpath
# # -e папка_1 папка_... = Исключить папки или файлы из сихронизации
# exclud_folder=$(__rsync-exlude-folder $@)
# SSH_RES="ssh -p $1"
# res="rsync -azvh --progress -e $SSH_RES $2 $3 $exclud_folder"
# echo $res
# eval $res
# }
##############
# -rsync-read-file() {
# # Прочитать файл с сохранеными путями синхронизации
# eval $(~py -c "
# import os.path
# file = '.rsyncpath'
# if os.path.exists(file):
# with open(file, 'r') as _f:
# print(_f.read())
# " $@)
# }
# __rsync-exlude-folder() {
# # -e папка_1 папка_... = Исключить папки или файлы из сихронизации
# # можно создать файл .rsyncignore(по типу .gitignore) для хранения исключений
# ~py -c "
# import os.path
# import sys
# def main(argv:list):
# '''
# >>> main(['sd', 'in', 'out', '-e', 'ewe', 'edde', 'deed'])
# --exclude=ewe --exclude=edde --exclude=deed
# '''
# file = '.rsyncignore'
# exclude = []
# # Получаем исключения из консоли
# exclude.extend(argv[3:])
# if exclude and exclude.pop(0) == '-e':
# # Получаем исключения из файла
# if os.path.exists(file):
# with open(file, 'r') as _f:
# exclude.extend(_f.read().split('\n'))
# res = ''
# for x in exclude:
# res += '--exclude=%s ' % x
# # убрать последний пробел
# res = res[:-1] if res.endswith(' ') else res
# print(res)
# else:
# print('', end='')
# main(sys.argv)
# " $@
# }
#!/bin/bash
####
# Работа с оброзом
###
dk-build() {
# Собрать образ
# $1 Имя для оброза
# $2 Путь к папке в которой расположен Dockergile
# $@ Остальные аргументы
# Собрать образ
q1="docker build -t $1 $2 ${@:3}"
echo $q1
eval $q1
# Путь куда сохранятсья настройки созданого образа
conf_docker_image=".conf_docker_image.json"
# Создать файл с конфигурациями образа
q2="docker inspect $1 > $2/$conf_docker_image"
echo $q2
eval $q2
}
dk-images() {
# Посмотреть образы
# $1 - Если -w то будет отлеживать
if [[ $1 == '-w' ]]; then
sudo watch -d -n 2 docker images
else
docker images
fi
}
dk-imag-rm() {
# Удалить указанный образ
# $1 - Имя оброза
docker image rm $1
}
####
# Работа с контейнером
###
alias dk="docker"
dk-run() {
# Создать и запустить контейнер из оброза
# $1 Имя для оброза
# $@ Остальные аргументы
# Путь куда сохранятсья настройки запущеного контейнера
conf_docker_container=".conf_docker_container.json"
# Запускаем контейнер и полуаем его ID
q1="docker run -it ${@:2} --rm -d $1"
echo $q1
container_id=$(eval $q1)
# Создать файл с конфигурациями образа
q2="docker inspect $container_id > $conf_docker_container"
echo $q2
eval $q2
}
dk-create() {
# Создать контейнер из оброза
# $1 Имя для оброза
# $@ Остальные аргументы
# Путь куда сохранятсья настройки запущеного контейнера
conf_docker_container=".conf_docker_container.json"
# Запускаем контейнер и полуаем его ID
container_id=$(docker create -it $1 ${@:2})
# Создать файл с конфигурациями образа
q2="docker inspect $container_id > $conf_docker_container"
echo $q2
eval $q2
}
dk-attach() {
# Подключиться выводу консоли контейнера
# $1 Имя контейнера
q1="docker container attach $1 ${@:2}"
echo $q1
eval $q1
}
dk-sh() {
# Войти в запущеннй контейнер
# $1 Имя контейнера
docker exec -ti $1 /bin/sh
}
dk-start() {
# Запустить существубщий контенер
# $1 Имя контейнера
docker container start $1
}
dk-stop() {
# Остановить существубщий контенер
# $1 Имя контейнера
docker container stop $1
}
dk-restart() {
# Перезапустить существубщий контенер
# $1 Имя контейнера
docker container restart $1
}
dk-ps() {
# Посмотреть контейнеры
# $1 - Если -w то будет отлеживать
if [[ $1 == '-w' ]]; then
watch -d -n 2 docker ps -a
else
docker ps -a
fi
}
dk-info-ip() {
# Получить ip адрес указанного контейнера
# $1 Имя контейнера
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' $1
}
###
# Общее
###
dk-prune() {
# Отчитстить контейнеры
docker container prune
# Отчитстить образы
docker container prune
}
#################################
# Docker-compose
#################################
alias dkp="docker-compose"
dkp-init() {
# Создать файл `docker-compose.yml` в текущем пути
touch docker-compose.yml
}
-docker-compose-select-envfile() {
# Сохранить путь к env файлу
# -docker-compose-select-env-file ./file/__env.env
__write-file $1 .env_path
}
-docker-compose-build() {
# Запустить образы контейнеров
if [[ -r .env_path ]]; then
docker-compose --env-file $(cat .env_path) build
fi
docker-compose build
}
-docker-compose-up() {
# Запустить контейнеры а после окончанию отчистить удалить их
if [[ -r .env_path ]]; then
docker-compose --env-file $(cat .env_path) up && docker-compose --env-file $(cat .env_path) rm -fsv
fi
docker-compose up && docker-compose rm -fsv
}
-docker-compose-rm() {
# Удалить ненужные контейнеры
if [[ -r .env_path ]]; then
docker-compose --env-file $(cat .env_path) rm -fsv
fi
docker-compose rm -fsv
}
#!/bin/bash
# Zsh
-zsh-hotkey() {
echo "
Ctrl+a = Переместить курсор в начало команды
Ctrl+e = Переместить курсор в конец команды
Ctrl+r = Поиск команды по истории
Ctrl+c = Прервать команду
Ctrl+z = Свернуть выполненеи команды (fg = вернуться)
Ctrl+w = Удалить слово в право
Ctrl+u = Удалить весь текст в лево
Ctrl+k = Удалить весь текст в право
Ctrl+y = Вставить текст
Ctrl+x затем Ctrl+e = Открыть команду в текстовом редакторе указанным в $(EDITOR), после выхода она вставиться в консоль
Ctrl+s = Поставить на паузу выполение команжы (Ctrl+q возобновить)
"
}
-zsh-edit() {
# Открыть редактирование zsh
$EDITOR ~/.zshrc
}
-zsh-install-plugin() {
# Установить плагины Zsh
git clone https://github.com/zsh-users/zsh-autosuggestions ~/.oh-my-zsh/custom/plugins/zsh-autosuggestions &&
git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ~/.oh-my-zsh/custom/plugins/zsh-syntax-highlighting &&
git clone https://github.com/marlonrichert/zsh-autocomplete.git ~/.oh-my-zsh/custom/plugins/zsh-autocomplete &&
mkdir $ZSH_CUSTOM/plugins/poetry &&
poetry completions zsh >$ZSH_CUSTOM/plugins/poetry/_poetry
}
-zsh-mount-disk() {
# Примонтировать повседневные диски
# Google Disk
google-drive-ocamlfuse /mnt/google_disk
}
-zsh-clean-history() {
# Отчистить историю команд
history -c
}
#!/bin/bash
##################################################
--() {
# Поиск документции у функции
---dev $@ | less
}
an() {
# Поиск алиасов по имени
aa-dev $@ -n | less
}
av() {
# Поиск алиасов по значению
aa-dev $@ -v | less
}
##################################################
##################################################
# Реализацию писать через постфикс -dev
---dev() {
# Поиск bash команды в папке bashler
#
# [часть_имени_команды]
#
~py -c "
import sys
sys.path.insert(0,'$BASHLER_PATH_PY')
from doc_serach import manger_search_func
manger_search_func()
" $@
}
aa-dev() {
# Посик алисов по значению и имени
#
# [часть_алиаса]
# -v = Поиск по знаечнию
# -n = Поиск по имени
~py -c "
import sys
sys.path.insert(0,'$BASHLER_PATH_PY')
from doc_serach import search_alias
search_alias()
" $@ $(alias)
alias | grep $1
}
#!/bin/bash
# SSH - Сервер
-ssh-keygen() {
# Сгенерировать ssh ключи
ssh-keygen
}
-ssh-restart() {
# Перезапутсить SSH сервер
res=''
if [[ $BASE_SYSTEM_OS == "termix" ]]; then
res="-ssh-stop && -ssh-start"
echo "Termix - SSH перезагружен "
elif [[ $BASE_SYSTEM_OS == "ubuntu" ]]; then
res="sudo systemctl restart shhd"
echo "Ubuntu - SSH перезагружен"
fi
echo $res
eval $res
}
-ssh-start() {
# Запустить SSH сервер
res=''
if [[ $BASE_SYSTEM_OS == "termix" ]]; then
res="sshd"
echo "Termix - SSH перезагружен "
elif [[ $BASE_SYSTEM_OS == "ubuntu" ]]; then
res="sudo systemctl start shhd"
echo "Ubuntu - SSH перезагружен "
fi
echo $res
eval $res
}
-ssh-stop() {
# Остановить SSH сервер
res=''
if [[ $BASE_SYSTEM_OS == "termix" ]]; then
res="pkill sshd"
echo "Termix - SSH перезагружен "
elif [[ $BASE_SYSTEM_OS == "ubuntu" ]]; then
res="sudo systemctl stop shhd"
echo "Ubuntu - SSH перезагружен "
fi
echo $res
eval $res
}
# SSH - Подключение к серверу
-ssh-c() {
# Поключиться по SSH
# $1 - Имя пользователя
# $2 - Host(ip) сервера
# $3 - Порт
port=22
if [[ -z $3 ]]; then
port=$3
fi
#
res=ssh -p 22 "$1@$2"
echo res
eval res
}
-ssh-cf() {
# Поключиться по SSH. Взять данные для подлючения из файла
# $1 - ПроизвольноеИмя из файла для ssh
res=$(-ssh-parse-conf $1)
user=$(echo $res | cut -d "|" -f 1)
host=$(echo $res | cut -d "|" -f 2)
port=$(echo $res | cut -d "|" -f 3)
echo "$user@$host:$port"
# Подключение по сереру
ssh -p $port "$user@$host"
}
-ssh-copy-key-cf() {
# Скопироввать SSH ключ. Взять данные для подлючения из файла
# $1 - ПроизвольноеИмя из файла для ssh
res=$(-ssh-parse-conf $1)
user=$(echo $res | cut -d "|" -f 1)
host=$(echo $res | cut -d "|" -f 2)
port=$(echo $res | cut -d "|" -f 3)
echo "$user@$host:$port"
ssh-copy-id -p $port "$user@$host"
}
-ssh-parse-conf() {
# Получаем данные для подключения по `ПроизвольноеИмяПодключения_SSH`
#
# $1 = ПроизвольноеИмяПодключения_SSH
#
res=$(~py -c '''
import pathlib
import sys
import json
path_to_remote_file = sys.argv[1]
name_connect_from_conf = sys.argv[2]
text_conf = pathlib.Path(path_to_remote_file).read_text()
json_conf = json.loads(text_conf)
conf = json_conf["ssh"].get(name_connect_from_conf)
if conf:
print(conf["user"], conf["host"], conf["port"], sep="|")
else:
raise KeyError(
f"Не найдено SSH подключение по имени - {name_connect_from_conf}"
)
''' $BASHLER_REMOTE_PATH $1)
echo $res
return 0 # Выйти из функции 0 хорошо 1 плохо
}
#!/bin/bash
sy-ie() {
# Проверить включена ли служба в автозапуск
sudo systemctl is-enabled $1
}
sy-e() {
# Добвить службу в автозапуск
sudo systemctl enabled $1
}
sy-d() {
# Удалить службу из автозапуска
sudo systemctl disable $1
}
sy-r() {
# Перезапустить службу
sudo systemctl restart $1
}
sy-s() {
# Статус службы
sudo systemctl status $1
}
sy-str() {
# Запустить службы
sudo systemctl start $1
}
sy-stp() {
# Остановить службу
sudo systemctl stop $1
}
#!/bin/bash
## Действия с папками
f-dir-copy() {
# Скопировать папку
cp -R $1 $2
}
f-dir-rename() {
# Переименовать папку
mv $1 $2
}
f-dir-create() {
# Создать папку
mkdir $1
}
f-dir-remove() {
# Удалить папку
rm -rf $1
}
## Размер Диска и использование его
d-size-folder() {
# Получить разме файлов в указанной директории
du $1 -ach -d 1 | sort -h
}
d-size-disk() {
# Использование дисков
df -h $@
}
d-list-disk() {
# Все подключенные диски
sudo fdisk -l
}
## Tree
-tree() {
# > УровеньВложенности ДиректориюПосмотерть
# -a = скрытые файлы
# -d = только директории
# -f = показать относительный путь для файлов
# -L = уровень вложенности
# -P = поиск по шаблону (* сделать на python)
# -h = Вывести размер файлов и папок
# -Q = Заключать названия в двойные кавычки
# -F = Добовлять символы отличия для папок, файлов и сокетов
# -I = Исключить из списка по патерну
res='tree -a -L'
if [[ -z $1 ]]; then
res+=' 3'
else
res+=" $1"
fi
res+=' -h -F'
if [[ -z $2 ]]; then
res+=' ./'
else
res+=" $2"
fi
echo $res
eval $res
}
## Python
-p-joinfile() {
# Объеденить текс всех файлов из указанной директории
# 1 - Путь к папке
# 2 - Кодировка файлов
# 3 - Разделитель при записи в итоговый файл
res=$(~py -c '''
import pathlib
import sys
# Путь к папке
dir=sys.argv[1]
# Кодировка файлов
encode=sys.argv[2] # "windows-1251"
# Разделитель при записи в итоговый файл
sep=sys.argv[3] # "\n"
res_text = []
p = pathlib.Path(dir).resolve()
for x in p.glob("*.txt"):
res_text.append(x.read_text(encode))
(p / "join.out").write_text(sep.join(res_text))
''' "$1" "$2" "$3")
echo $res
}
#!/bin/bash
# Работа с пакетными менеджарами
pinst() {
# Установить программу в Linux
RES_EXE="$(~py -c '''
import json
import sys
import re
from pathlib import Path
import os
platform = sys.argv[-1]
pakage = sys.argv[1]
# Установка программы
if platform == "ubuntu":
if re.search(".deb$", pakage):
# Установка из файла
print("p-apt-install-file")
else:
# Установка из интернета
print("p-apt-install")
elif platform == "arch":
print("p-packman-install")
elif platform == "termux":
print("p-pkg-install")
else:
print("None")
''' $1 $BASE_SYSTEM_OS) $@"
echo $RES_EXE
eval $RES_EXE && ~py -c '''
# Добавить программу в `.bashler_pinst`
import json
import sys
import re
from pathlib import Path
import os
platform = sys.argv[-1]
pakage = sys.argv[1]
# Чтение файла `.bashler_pinst`
home = os.environ["HOME"]
path_bashler_pinst = Path(f"{home}/.bashler_pinst")
text = path_bashler_pinst.read_text()
if not text:
text = "{}"
dict_app = json.loads(text)
# Добавляем приложение
dict_app[pakage] = ""
# Запись в файл `.bashler_pinst`
with open(path_bashler_pinst, "w") as _jsonFile:
json.dump(dict_app, _jsonFile, skipkeys=False, sort_keys=True, indent=4, ensure_ascii=False)
''' $1 $BASE_SYSTEM_OS
}
prem() {
# Удалить указаный пакет
RES_EXE="$(~py -c '''
import sys
import re
os = sys.argv[-1]
pakage = sys.argv[1]
if os == "ubuntu":
if re.search(".deb$", pakage):
# Удалить из файла
print("p-apt-remove")
else:
# Удалить из интернета
print("p-apt-remove")
elif os == "arch":
print("p-packman-remove")
elif os == "termux":
print("p-pkg-remove")
else:
print("None")
''' $1 $BASE_SYSTEM_OS) $@"
echo $RES_EXE
eval $RES_EXE && ~py -c '''
# Добавить программу в `.bashler_pinst`
import json
import sys
import re
from pathlib import Path
import os
platform = sys.argv[-1]
pakage = sys.argv[1]
# Чтение файла `.bashler_pinst`
home = os.environ["HOME"]
path_bashler_pinst = Path(f"{home}/.bashler_pinst")
text = path_bashler_pinst.read_text()
if not text:
text = "{}"
dict_app = json.loads(text)
# Убрать приложение
dict_app.pop(pakage)
# Запись в файл `.bashler_pinst`
with open(path_bashler_pinst, "w") as _jsonFile:
json.dump(dict_app, _jsonFile, skipkeys=False, sort_keys=True, indent=4, ensure_ascii=False)
''' $1 $BASE_SYSTEM_OS
}
pupd() {
# Обновить все пакеты
res=''
if [[ $BASE_SYSTEM_OS == "termix" ]]; then
res="p-pkg-update"
elif [[ $BASE_SYSTEM_OS == "ubuntu" ]]; then
res="p-apt-update && p-snap-update && p-flatpack-update"
elif [[ $BASE_SYSTEM_OS == "ubuntu" ]]; then
res="p-packman-update"
fi
eval $res
}
#############
p-apt-baseinstall() {
# Устновить все необходимые программы
res=~py -c "
import sys
is_server=sys.argv[1]
if is_server = 'yes':
print('Server')
print('Client')
if input('Установить зависемости ? (y/n)') == 'y':
if is_server:
os.system('''
# Обновить пакеты
p-apt-update;
# Установить пакеты
sudo apt install git curl wget vim nginx net-tools make tree;
''')
else:
os.system('''
# Обновим пакеты apt
p-apt-update;
# Устоновим пакетный менеджер flatpak и snap
sudo apt install flatpak snap
# Обновить все пакеты в системе
p-full-update;
# Установить базовые пакеты
sudo apt install git zsh curl micro keepassx net-tools make krusader;
# Программы snap
sudo snap install code --classic;
'''
)
else:
print('Отставить!')
" $IS_SERVER
}
# -------------------------
p-apt-install() {
# Установить программу
sudo apt install $@
}
p-pkg-install() {
pkg install $@
}
p-apt-install-file() {
# Установить из файла
# sudo dpkg -i $1
p-apt-install $1
}
# -------------------------
p-apt-remove() {
# Установить программу
sudo apt remove $@
}
p-pkg-remove() {
pkg uninstall $@
}
# -------------------------
p-apt-update() {
# Обновить ссылки, программы, отчистить лишнее
sudo apt update && sudo apt upgrade -y && sudo apt autoremove && sudo apt clean
}
p-pkg-update() {
# Обнавления для Termix
pkg update && pkg upgrade -y && pkg autoclean && apt autoremove
}
p-packman-update() {
# Обновления для Pacman
sudo pacman -Syu
}
p-snap-update() {
# Обнавить программы из Snap
snap refresh --list
snap refresh
}
p-flatpack-update() {
# Обнавить программы из flatpak
flatpak update
}
# -------------------------
#!/bin/bash
## S = система
s-watch(){
# Обновление команды через определенный период времяни
watch -d -n $@
}
#!/bin/bash
export Wireguard_VPN_CONF="wg0"
###
# WireGuard
#
-vpn-on() {
# Включить VPN
sudo wg-quick up $Wireguard_VPN_CONF
}
-vpn-off() {
# Выключить VPN
sudo wg-quick down $Wireguard_VPN_CONF
}
-vpn-info() {
# Информация о подключение к VPN
sudo wg show
}
###
# OpenVpn
#
-open-vpn-on() {
printf 'OpenVpn включен\n'
# Включить OpenVpn
sudo openvpn /etc/openvpn/client/client.ovpn
}
#!/bin/bash
ffmpeg-video-to-audio() {
# Извлечь аудио из видео
# $1 = Путь к видео
res="ffmpeg -i '$1' -vn -acodec copy '$(basename $1 | cut -d. -f1).m4a'"
echo $res
eval $res
}
ffmpeg-video-to-audio-dir() {
# Извлечь аудио из видео, в текущей папке.
# $1 = Расширение для видео которые нужно конертировать
ext="*.mp4"
if [ -n "$1" ]; then
ext="*$1"
fi
res="
for file in $ext
do
r=\"ffmpeg-video-to-audio '\$file'\"
echo \$r
eval \$r
done
"
eval $res
}
ffmpeg-cup() {
# Обрезать длительносить видео
# $1 = Путь к видео
# $2 = Продолжительность
# $3 = Откуда начать отсчёт продолжительности, по умолчнаию с начала видео
time_long='1:00'
start_time='00:00:00'
if [ -n "$3" ]; then
start_time="$3"
fi
if [ -n "$2" ]; then
time_long="$2"
fi
new_name_file=$(echo "$start_time $time_long" | sed 's/:/_/g')
res="ffmpeg -i '$1' -ss $start_time -t $time_long '$new_name_file $1' "
echo $res
eval $res
}
ffmpeg-remove-audio-from-video() {
# Удалить аудио дорожку у указаного видео
# $1 = Путь к видео
res="ffmpeg -i '$1' -c:v copy -an 'del_audio_$1'"
echo $res
eval $res
}
ffmpeg-join-audio-to-video() {
# Обьеденить музыку с видео.
# $1 = Путь к видео
# $2 = Путь к музыке
ffmpeg-remove-audio-from-video $1
res="ffmpeg -i 'del_audio_$1' -i $2 -c:v copy -c:a aac -strict experimental 'join_$(basename $2 | cut -d. -f1)_$1'"
echo $res
eval $res
}
pytube-download() {
# Скачать видео с Yotube
# $1 = Url ссылка на видео
~py -c "from pytube import YouTube;YouTube(\"$1\").streams.filter(progressive=True, file_extension='mp4').order_by('resolution').desc().first().download()"
}
#!/bin/bash
#
## Рабата с видео и Gif
#
-gifzip() {
# Сжать Gif видео
e="gifsicle -i \"$1\" -o \"out_$1\" --optimize=3 --colors=256 --lossy=30"
echo $e
eval $e
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment