diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml
index 928c252..16a4ec6 100644
--- a/.github/workflows/pr.yml
+++ b/.github/workflows/pr.yml
@@ -7,24 +7,26 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  format:
+  pre-commit:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
-      - name: Run black formatter
-        uses: psf/black@stable
+        uses: actions/checkout@v4
         with:
-          src: media_management_scripts
+          fetch-depth: 0
+      - name: Run pre-commit
+        uses: pre-commit/action@v3.0.0
   test:
     runs-on: ubuntu-latest
     strategy:
       matrix:
         python-version: ["3.9", "3.10", "3.11"]
-    needs: format
+    needs: pre-commit
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
       - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v4
         with:
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
new file mode 100644
index 0000000..6293620
--- /dev/null
+++ b/.github/workflows/publish.yml
@@ -0,0 +1,37 @@
+name: Publish releases
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - 'v*'
+
+jobs:
+  build-and-publish:
+    name: Build and publish
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.10'
+    - name: Install pypa/setuptools
+      run: |
+        python -m pip install build
+    - name: Build wheels
+      run: |
+        python3 -m build --sdist --wheel --outdir dist/ .
+    - name: Publish distribution to Test PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        password: ${{ secrets.TEST_PYPI_API_TOKEN }}
+        repository-url: https://test.pypi.org/legacy/
+    - name: Publish distribution to PyPI if tagged
+      if: startsWith(github.ref, 'refs/tags')
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        password: ${{ secrets.PYPI_API_TOKEN }}
diff --git a/.gitignore b/.gitignore
index 3a2259c..d38a4ab 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,14 +1,155 @@
-*.log
-dist/
-deploy.sh
-*.pyc
-node_modules/
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
 build/
-static/
-*.sqlite3
-.idea/
-awsCredentials.py
-temperature_package.tgz
-.coverage
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
 *.egg-info/
-.vscode/
\ No newline at end of file
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+.vscode/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..cd149a4
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,14 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.2.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+  - repo: https://github.com/psf/black
+    rev: 23.9.1
+    hooks:
+      - id: black
diff --git a/README.md b/README.md
index 513c95c..f2f84d9 100644
--- a/README.md
+++ b/README.md
@@ -47,7 +47,7 @@ __[rename](#rename)__
 __[search](#search)__
 
 __[tv-rename](#tv-rename)__
- 
+
 
 Help output
 ```
@@ -158,7 +158,7 @@ Battlestar Galatica (2003) - s00e01 - Battlestar Galactica The Miniseries (1).mk
 
 ## rename
 
-`manage-media rename <template> <input file>` or `manage-media rename --recursive <template> <input directory>` 
+`manage-media rename <template> <input file>` or `manage-media rename --recursive <template> <input directory>`
 
 A flexible tool to rename files
 
@@ -272,7 +272,7 @@ For example, if you ripped some Battlestar Galactica blurays, you might have a f
     - BSG_Season1_Disc2_t01.mkv
     - BSG_Season1_Disc2_t02.mkv
     - BSG_Season1_Disc2_t03.mkv
-   
+
 `manage-media tv-rename -s 1 -e 1 --tvdb --show "Battlestar Galactica" --output "BSG/Season 1" BSG_Season1_Disc*`
 
 Result
@@ -286,8 +286,8 @@ Result
         - Battlestar Galatica (2003) - S01E06 - Litmus.mkv
         - Battlestar Galatica (2003) - S01E07 - Six Degrees of Separation.mkv
         - Battlestar Galatica (2003) - S01E08 - Flesh and Bone.mkv
-        
-        
+
+
 ## Configuration
 
 You can configuration where to find various executables by creating a file `~/.config/mms/config.ini`. By default, commands will use the executables found in your path.
diff --git a/bin/convert-dvds b/bin/convert-dvds
deleted file mode 100755
index cf984c9..0000000
--- a/bin/convert-dvds
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/usr/bin/env python
-# PYTHON_ARGCOMPLETE_OK
-from media_management_scripts.convert_daemon import main
-
-main()
diff --git a/bin/manage-media b/bin/manage-media
deleted file mode 100755
index 8c8788b..0000000
--- a/bin/manage-media
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/usr/bin/env python
-# PYTHON_ARGCOMPLETE_OK
-from media_management_scripts.main import main
-
-main()
diff --git a/bin/silver-tube b/bin/silver-tube
deleted file mode 100644
index f155748..0000000
--- a/bin/silver-tube
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/usr/bin/env python
-# PYTHON_ARGCOMPLETE_OK
-
-from media_management_scripts.silver_tube import main
-
-main()
diff --git a/bin/tvdb-api b/bin/tvdb-api
deleted file mode 100644
index 2cb4db2..0000000
--- a/bin/tvdb-api
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/usr/bin/env python
-# PYTHON_ARGCOMPLETE_OK
-
-from media_management_scripts.tvdb_api import main
-
-main()
diff --git a/media_management_scripts/__init__.py b/media_management_scripts/__init__.py
index a90a028..91ce095 100644
--- a/media_management_scripts/__init__.py
+++ b/media_management_scripts/__init__.py
@@ -1 +1,6 @@
-version = "0.4.4"
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("media_management_scripts")
+except PackageNotFoundError:
+    __version__ = "unknown version"
diff --git a/media_management_scripts/commands/__init__.py b/media_management_scripts/commands/__init__.py
index d73ddd4..d566112 100644
--- a/media_management_scripts/commands/__init__.py
+++ b/media_management_scripts/commands/__init__.py
@@ -152,7 +152,7 @@ def _bulk_print(
     "itunes",
     "metadata",
     "metadata_compare",
-    #'movie_rename',
+    "movie_rename",
     "rename",
     "search",
     "select_streams",
diff --git a/media_management_scripts/commands/convert.py b/media_management_scripts/commands/convert.py
index 26466f4..52163a4 100644
--- a/media_management_scripts/commands/convert.py
+++ b/media_management_scripts/commands/convert.py
@@ -20,7 +20,7 @@ def name(self):
     def build_argparse(self, subparser):
         desc = """
     Converts a video file to 'standard' parameters. By default, this is H264 with AAC audio.
-    
+
     Convert to HEVC/H.265:
         convert --video-codec hevc <input> <output>
     Convert to HEVC with AC3 audio:
diff --git a/media_management_scripts/commands/movie_rename.py b/media_management_scripts/commands/movie_rename.py
index d29c195..2270515 100644
--- a/media_management_scripts/commands/movie_rename.py
+++ b/media_management_scripts/commands/movie_rename.py
@@ -20,12 +20,6 @@ def build_argparse(self, subparser):
             const=True,
             default=False,
         )
-        movie_rename_parser.add_argument("--ssh")
-        movie_rename_parser.add_argument("--username")
-        movie_rename_parser.add_argument("--host")
-        movie_rename_parser.add_argument("--pkey")
-        movie_rename_parser.add_argument("--output-path", "-o")
-        movie_rename_parser.add_argument("--move-source-path", default=None)
         movie_rename_parser.add_argument("input", nargs="+", help="Input Files")
 
     def subexecute(self, ns):
diff --git a/media_management_scripts/commands/rename.py b/media_management_scripts/commands/rename.py
index dc8382b..ed910b0 100644
--- a/media_management_scripts/commands/rename.py
+++ b/media_management_scripts/commands/rename.py
@@ -18,40 +18,40 @@ def build_argparse(self, subparser):
             formatter_class=argparse.RawTextHelpFormatter,
             description="""
     Rename files based on a template.
-    
+
     Templates can include variables or expressions by surrounding with ${...}. Functions can be called like ${upper(i)} or ${i | upper}.
-    
+
     The following variables are available:
         * i/index - The index of the current file being renamed
         * wo_ext - The file name basename without the extension
         * ext - The file extension of the current file (without '.')
         * filename - The filename of the current file (basename)
         * re/regex - A list of regex match groups (use re[0], re[1], etc)
-    
+
     The following functions are available:
         * upper - Upper cases the input
         * lower - Lower cases the input
         * ifempty(a, b, c) - If a is empty or null, then b, otherwise c
         * lpad(a, b:int) - Left pads a to length b (defaults to 2+) with spaces
         * zpad(a, b:int) - Left pads a to length b (defaults to 2+) with zeros
-    
+
     lpad/zpad - By default pads to at least 2 characters. If there are 100+ files, then 3 characters, 1000+ files, then 4 characters, etc.
-    
+
     Regular Expressions:
     If a regex is included, the match groups (0=whole match, >0=match group) are available in a list 're' or 'regex'.
     Each match group is converted to an int if possible, so a zero padded int will lose the zeros.
-    
+
     Examples:
     Input: S02E04.mp4
     Regex: S(\d+)E(\d+)
-    
+
     Template: 'Season ${re[1]} Episode ${re[2]}.{ext}'
     Result: 'Season 2 Episode 4.mp4'
-    
+
     Template: Template: 'Season ${re[1] | zpad} Episode ${zpad(re[2], 3)}.{ext}'
     Results: 'Season 02 Episode 004.mp4'
-    
-    
+
+
     Input: whatever.mp4
     Regex: S(\d+)E(\d)
     Template: 'Season ${ifempty(re[1], 'unknown', re[1])} Episode ${re[2]}.{ext}'
diff --git a/media_management_scripts/commands/search.py b/media_management_scripts/commands/search.py
index d781082..73ff0aa 100644
--- a/media_management_scripts/commands/search.py
+++ b/media_management_scripts/commands/search.py
@@ -16,9 +16,9 @@ def build_argparse(self, subparser):
             formatter_class=argparse.RawTextHelpFormatter,
             description="""
     Searches a directory for video files matching parameters.
-    
+
     If a video has multiple streams, comparisons mean at least one stream matches.
-    
+
     Available parameters:
     Video:
         v.codec - The video codec (h264, h265, mpeg2, etc)
@@ -37,11 +37,11 @@ def build_argparse(self, subparser):
         resolution - The resolution name (LOW_DEF, HIGH_DEF, etc)
     Metadata:
         meta.xyz - Follows the basic JSON metadata output
-    
+
     Functions:
         isNull(xyz) - Returns true if the value is null
         all(xyz) - Instead of one stream matching, check all of them
-    
+
     Examples:
         Find all videos that are H264
             v.codec = h264
diff --git a/media_management_scripts/main.py b/media_management_scripts/main.py
index 6b873e0..245bd88 100644
--- a/media_management_scripts/main.py
+++ b/media_management_scripts/main.py
@@ -3,7 +3,7 @@
 import sys
 
 from media_management_scripts.commands import *
-from media_management_scripts import version
+from media_management_scripts import __version__ as version
 
 COMMANDS = {k.name: k for k in [x() for x in SubCommand.__subclasses__()]}
 
diff --git a/media_management_scripts/processed.shelve b/media_management_scripts/processed.shelve
deleted file mode 100644
index 64e4a7c..0000000
Binary files a/media_management_scripts/processed.shelve and /dev/null differ
diff --git a/media_management_scripts/silver_tube/__init__.py b/media_management_scripts/silver_tube/__init__.py
deleted file mode 100644
index f2f5153..0000000
--- a/media_management_scripts/silver_tube/__init__.py
+++ /dev/null
@@ -1,64 +0,0 @@
-import argparse
-
-from media_management_scripts.silver_tube.delete_process import run_delete
-
-
-def create_arg_parse() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser()
-    subparsers = parser.add_subparsers(help="Sub commands", dest="command")
-
-    process_parser = subparsers.add_parser("process", help="Process recorded TV files")
-    process_parser.add_argument("config", type=str, help="Configuration file")
-    process_parser.add_argument(
-        "--tvdb-config", type=str, help="TVDB credential file", default=None
-    )
-
-    db_parser = subparsers.add_parser("db", help="Handle unmatched files in database")
-    db_parser.add_argument(
-        "--skip-no-options",
-        "-s",
-        help="Skip files which have zero options",
-        dest="skip_no_options",
-        default=False,
-        action="store_const",
-        const=True,
-    )
-    db_parser.add_argument("db-file", type=str, help="Database file")
-
-    delete_parser = subparsers.add_parser("delete", help="Delete recorded TV files")
-    delete_parser.add_argument("config", type=str, help="Configuration file")
-
-    return parser
-
-
-def handle(ns):
-    cmd = ns["command"]
-    if cmd == "process":
-        from media_management_scripts.silver_tube.processing import Configuration
-        from media_management_scripts.tvdb_api import (
-            from_config,
-            DEFAULT_CONFIG_LOCATION,
-        )
-
-        config_file = ns["config"]
-        tvdb = from_config(ns.get("tvdb_config", DEFAULT_CONFIG_LOCATION))
-        config = Configuration(config_file, tvdb)
-        config.run()
-    elif cmd == "db":
-        from media_management_scripts.silver_tube.wtv_db import WtvDb
-
-        db_file = ns["db_file"]
-        wtvdb = WtvDb(db_file)
-        skip_no_options = ns["skip_no_options"]
-        wtvdb.begin()
-        wtvdb.resolve_all(skip_no_options)
-        wtvdb.end()
-    elif cmd == "delete":
-        config_file = ns["config"]
-        run_delete(config_file)
-
-
-def main():
-    parser = create_arg_parse()
-    ns = vars(parser.parse_args())
-    handle(ns)
diff --git a/media_management_scripts/silver_tube/delete_process.py b/media_management_scripts/silver_tube/delete_process.py
deleted file mode 100644
index 6e90602..0000000
--- a/media_management_scripts/silver_tube/delete_process.py
+++ /dev/null
@@ -1,61 +0,0 @@
-import json
-import re
-from datetime import datetime
-from typing import NamedTuple, Iterable
-import os
-import itertools
-
-
-class TvShow(NamedTuple):
-    file_path: str
-    show: str
-    network: str
-    recorded_datetime: datetime
-
-
-def _parse_dir(dir) -> Iterable[TvShow]:
-    pattern = re.compile(r"(.+)_(.+)_(\d{4})_(\d\d)_(\d\d)_(\d\d)_(\d\d)_(\d\d).wtv")
-    for file in os.listdir(dir):
-        m = pattern.search(file)
-        if m:
-            filepath = os.path.join(dir, file)
-            show = m.group(1)
-            network = m.group(2)
-            recorded_datetime = datetime(
-                year=int(m.group(3)),
-                month=int(m.group(4)),
-                day=int(m.group(5)),
-                hour=int(m.group(6)),
-                minute=int(m.group(7)),
-                second=int(m.group(8)),
-            )
-            yield TvShow(filepath, show, network, recorded_datetime)
-
-
-def run_delete(config_file, dry_run=True):
-    """
-    Deletes WTV files in a directory based on a configuration file
-    :param config_file:
-    :param dry_run:
-    :return:
-    """
-    with open(config_file, "r") as file:
-        config = json.load(file)
-
-    dir = config["directory"]
-    tv_shows_config = config["tv_shows"]
-
-    key = lambda x: x.show
-
-    for show, files in itertools.groupby(sorted(_parse_dir(dir), key=key), key=key):
-        if show in tv_shows_config:
-            files = list(files)
-            max_count = tv_shows_config[show]
-            num_to_delete = len(files) - max_count
-            if max_count > 0 and num_to_delete > 0:
-                files.sort(key=lambda x: x.recorded_datetime)
-                to_delete = files[:num_to_delete]
-                for d in to_delete:
-                    print("{}".format(os.path.basename(d.file_path)))
-                    if not dry_run:
-                        os.remove(d.file_path)
diff --git a/media_management_scripts/silver_tube/processing.py b/media_management_scripts/silver_tube/processing.py
deleted file mode 100644
index d3f5207..0000000
--- a/media_management_scripts/silver_tube/processing.py
+++ /dev/null
@@ -1,432 +0,0 @@
-import xml.etree.ElementTree as ET
-from media_management_scripts.utils import (
-    create_metadata_extractor,
-    convert_config_from_config_section,
-)
-from media_management_scripts.silver_tube.wtv import extract_original_air_date
-from media_management_scripts import tvdb_api
-from media_management_scripts.silver_tube.wtv_db import WtvDb
-from media_management_scripts.convert import convert_with_config
-from media_management_scripts.support.episode_finder import extract as extract_season_ep
-from media_management_scripts.support.executables import ccextractor, comskip
-import os
-import subprocess
-import logging
-import logging.config
-import pysrt
-from copy import copy
-import configparser
-import datetime
-import glob
-from string import Template
-from typing import Tuple, List
-
-from media_management_scripts.support.executables import (
-    execute_with_output,
-    ffmpeg,
-    execute_with_timeout,
-    nice_exe,
-)
-from media_management_scripts.renamer import create_namespace
-from tempita import Template
-
-logger = logging.getLogger(__name__)
-exe_logger = logging.getLogger("executable-logger")
-
-
-class Configuration:
-    def __init__(self, config_file, tvdb):
-        config = configparser.ConfigParser()
-        config.read(config_file)
-        log_file = config.get("main", "log.config", fallback=None)
-        if log_file:
-            import yaml
-
-            with open(log_file) as f:
-                log_config = yaml.load(f)
-                logging.config.dictConfig(log_config)
-
-        template = config.get(
-            "directories",
-            "out.pattern",
-            fallback="${series}/Season ${season}/${series} - S${season|zpad}E${episode|zpad} - ${episode_name}.${ext}",
-        )
-        self.template = template
-
-        self.wtv_in_dir = config.get("directories", "tv.in")
-        self.tv_pattern = config.get("directories", "tv.pattern")
-        self.com_in_dir = config.get("directories", "commercial.in")
-        self.srt_in_dir = config.get("directories", "srt.in")
-        self.temp_dir = config.get("directories", "temp.dir")
-        self.out_dir = config.get("directories", "out.dir")
-        self.delete_source = config.getboolean(
-            "directories", "delete.source.files", fallback=True
-        )
-
-        self.convert_config = convert_config_from_config_section(config, "transcode")
-
-        if config.has_section("ffmpeg"):
-            logger.error("You are using an outdated configuration")
-            raise Exception("You are using an outdated configuration")
-
-        self.debug = config.getboolean("main", "debug", fallback=False)
-
-        self.ccextractor_exe = config.get(
-            "ccextractor", "executable", fallback=ccextractor()
-        )
-        self.ccextractor_run = config.getboolean(
-            "ccextractor", "run.if.missing", fallback=False
-        )
-
-        self.comskip_exe = config.get("comskip", "executable", fallback=None)
-        self.comskip_run = config.getboolean(
-            "comskip", "run.if.missing", fallback=comskip()
-        )
-        self.comskip_ini = config.get("comskip", "comskip.ini", fallback=None)
-
-        db_file = config.get("main", "database.file", fallback="db.sqlite")
-
-        self.wtvdb = WtvDb(db_file)
-        self.tvdb = tvdb
-
-        if self.convert_config.include_subtitles:
-            logger.warning(
-                "Include Subtitles is True. This usually does not work with TV captions."
-            )
-
-    def get_metadata(self, wtv_file: str) -> Tuple[str, str, int, int]:
-        # Will detect deinterlace if we actually have to process this file
-        metadata = create_metadata_extractor().extract(wtv_file, detect_interlace=False)
-        series = metadata.tags.get("Title", None)
-        episode_name = metadata.tags.get("WM/SubTitle", None)
-        # WM/SubTitleDescription
-
-        filename = os.path.basename(wtv_file)
-        wtv_obj = self.wtvdb.get_wtv(filename)
-        if wtv_obj and wtv_obj.selected_episode:
-            ep = wtv_obj.selected_episode.episode
-            season = ep.season
-            episode_num = ep.episode_num
-            if episode_name is None:
-                episode_name = ep.name
-        elif series is not None:
-            # Get season & episode number
-            air_date = extract_original_air_date(
-                wtv_file, parse_from_filename=True, metadata=metadata
-            )
-            episodes = self.tvdb.find_episode(
-                series, episode=episode_name, air_date=air_date
-            )
-            if len(episodes) == 1:
-                season, episode_num = tvdb_api.TVDB.season_number(episodes[0])
-                if episodes[0]["episodeName"] is not None:
-                    episode_name = episodes[0]["episodeName"]
-            else:
-                # Handle multiple options
-                self.wtvdb.store_candidates(self.tvdb, filename, metadata, episodes)
-                season = None
-                episode_num = None
-        else:
-            season = None
-            episode_num = None
-
-        # Try searching the description
-        if (
-            season is None
-            and episode_num is None
-            and "WM/SubTitleDescription" in metadata.tags
-        ):
-            season, episode_num, _ = extract_season_ep(
-                metadata.tags["WM/SubTitleDescription"]
-            )
-
-        if episode_name is None and episode_num is not None:
-            episode_name = "Episode #{}".format(episode_num)
-
-        return series, episode_name, season, episode_num, metadata
-
-    def process(self, wtv_file: str, com_file: str, srt_file: str):
-        # Ensure TVDB client is authenticated
-        self.tvdb.refresh()
-
-        series, episode_name, season, episode_num, metadata = self.get_metadata(
-            wtv_file
-        )
-        if series is not None and season is not None and episode_num is not None:
-            # Detect interlace
-            create_metadata_extractor().add_interlace_report(metadata)
-            filename = os.path.basename(wtv_file)
-            filename_wo_ext = os.path.splitext(filename)[0]
-            out_video = os.path.join(
-                self.out_dir,
-                create_filename(
-                    self.template,
-                    series,
-                    season,
-                    episode_num,
-                    episode_name,
-                    filename_wo_ext,
-                    "mp4",
-                ),
-            )
-            out_srt = os.path.join(
-                self.out_dir,
-                create_filename(
-                    self.template,
-                    series,
-                    season,
-                    episode_num,
-                    episode_name,
-                    filename_wo_ext,
-                    "eng.srt",
-                ),
-            )
-
-            if not os.path.exists(os.path.dirname(out_video)):
-                os.makedirs(os.path.dirname(out_video))
-            if not os.path.exists(os.path.dirname(out_srt)):
-                os.makedirs(os.path.dirname(out_srt))
-
-            commercials = parse_commercial_file(com_file)
-            split_subtitles(srt_file, invert_commercial(commercials), out_srt)
-            successful = self.convert(wtv_file, out_video, commercials, metadata)
-            if successful:
-                # If we finished with the WTV, delete it
-                if self.wtvdb.get_wtv(filename) is not None:
-                    self.wtvdb.delete_wtv(filename)
-                if not self.debug and self.delete_source:
-                    os.remove(wtv_file)
-                    os.remove(com_file)
-                    os.remove(srt_file)
-                logger.info("Completed {} => {}".format(wtv_file, out_video))
-            else:
-                logger.warning("Failure to convert {}".format(wtv_file))
-        else:
-            logger.warning(
-                "Missing data for {}: series={}, episode_name={}, season={}, episode_num={}".format(
-                    wtv_file, series, episode_name, season, episode_num
-                )
-            )
-
-    def extract_subtitles(self, wtv_file, out_srt):
-        execute_with_output([self.ccextractor_exe, wtv_file, "-o", out_srt])
-
-    def run_comskip(self, wtv_file, out_dir):
-        try:
-            if self.comskip_ini:
-                ret, stdout = execute_with_timeout(
-                    [
-                        self.comskip_exe,
-                        "--ini=" + self.comskip_ini,
-                        "--output=" + out_dir,
-                        wtv_file,
-                    ],
-                    timeout=60 * 10,
-                )
-            else:
-                ret, stdout = execute_with_timeout(
-                    [self.comskip_exe, "--output=" + out_dir, wtv_file],
-                    timeout=60 * 10,
-                    log_output=True,
-                )
-            if ret != 0:
-                logger.error("Comskip error: {}, Output={}".format(ret, stdout))
-                return False
-            else:
-                return True
-        except subprocess.TimeoutExpired:
-            return False
-
-    def cut_args(self, invert_com, out_name):
-        # -ss 0 -t 10 -c:v libx264 -preset ultrafast -crf 18 -c:a aac -strict -2 0.mp4
-        args = ["-ss", str(invert_com[0])]
-        if invert_com[1]:
-            args.extend(["-to", str(invert_com[1])])
-        args.extend(["-c:v", "copy", "-c:a", "copy"])
-        args.append(out_name)
-        return args
-
-    def convert(self, in_file, out_file, commercials, metadata):
-        invert = invert_commercial(commercials)
-        temp_files = []
-        wo_ext = os.path.basename(in_file).replace(".wtv", "")
-        try:
-            args = [ffmpeg(), "-i", in_file]
-            for i in invert:
-                temp_file = os.path.join(
-                    self.temp_dir, wo_ext + "." + str(len(temp_files)) + ".ts"
-                )
-                temp_files.append(temp_file)
-                if os.path.isfile(temp_file):
-                    os.remove(temp_file)
-                args.extend(self.cut_args(i, temp_file))
-
-            ret, output = execute_with_output(args)
-            if ret != 0:
-                logger.error("Nonzero return code from ffmpeg: {}".format(ret))
-                return False
-            else:
-                input = "concat:{}".format("|".join(temp_files))
-                ret = convert_with_config(
-                    input,
-                    out_file,
-                    config=self.convert_config,
-                    print_output=False,
-                    overwrite=True,
-                    metadata=metadata,
-                )
-                if ret != 0:
-                    logger.error("Nonzero return code from ffmpeg: {}".format(ret))
-                # Cleanup temp files
-                if not self.debug:
-                    for f in temp_files:
-                        os.remove(f)
-        except Exception as e:
-            logger.exception("Exception")
-            return False
-        return True
-
-    def run(self):
-        wtv_dir, com_dir, srt_dir = self.wtv_in_dir, self.com_in_dir, self.srt_in_dir
-        self.count = 0
-        files = glob.glob(os.path.join(wtv_dir, self.tv_pattern))
-        for wtv_file in sorted(files):
-            if os.path.isfile(wtv_file):
-                self.wtvdb.begin()
-                try:
-                    # wtv_file = os.path.join(wtv_dir, wtv)
-                    wtv = os.path.basename(wtv_file)
-                    time = datetime.datetime.now() - datetime.timedelta(minutes=5)
-                    modified = datetime.datetime.fromtimestamp(
-                        os.path.getmtime(wtv_file)
-                    )
-                    if modified < time:
-                        com = wtv.replace("wtv", "xml")
-                        srt = wtv.replace("wtv", "srt")
-                        com_file = os.path.join(com_dir, com)
-                        srt_file = os.path.join(srt_dir, srt)
-                        if not os.path.isfile(com_file) and self.comskip_run:
-                            logger.debug(
-                                "No commercial file for {}. Running comskip".format(
-                                    wtv_file
-                                )
-                            )
-                            if not self.run_comskip(wtv_file, com_dir):
-                                logger.error(
-                                    "Comskip error or timed out for: {}".format(
-                                        wtv_file
-                                    )
-                                )
-                                continue
-                        if not os.path.isfile(srt_file) and self.ccextractor_run:
-                            logger.debug(
-                                "No srt file for {}. Running ccextractor".format(
-                                    wtv_file
-                                )
-                            )
-                            self.extract_subtitles(wtv_file, srt_file)
-                        if os.path.isfile(com_file) and os.path.isfile(srt_file):
-                            logger.info("Processing {}".format(wtv_file))
-                            self.process(wtv_file, com_file, srt_file)
-                            self.count += 1
-                        elif not os.path.isfile(com_file):
-                            logger.warning(
-                                "No commercial file for {}...skipping".format(wtv_file)
-                            )
-                        else:
-                            logger.warning(
-                                "No srt file for {}...skipping".format(wtv_file)
-                            )
-                    else:
-                        logger.debug("File too new, skipping: {}".format(wtv))
-                except Exception:
-                    logger.exception("Exception while handling {}".format(wtv))
-                    self.wtvdb.end()
-        logger.info("Processed {} files".format(self.count))
-
-
-def parse_commercial_file(com_file) -> List[Tuple[float, float]]:
-    tree = ET.parse(com_file)
-    root = tree.getroot()
-    commercials = []
-    for child in root:
-        commercials.append((float(child.get("start")), float(child.get("end"))))
-    return commercials
-
-
-def invert_commercial(commercials):
-    inverse = [(0, commercials[0][0])]
-    for i in range(len(commercials) - 1):
-        left = commercials[i]
-        right = commercials[i + 1]
-        inverse.append((left[1], right[0]))
-    if len(commercials) > 1:
-        inverse.append((commercials[len(commercials) - 1][1], None))
-    return inverse
-
-
-def to_time(c):
-    c = float(c)
-    hours = int(c / (60 * 60))
-    minutes = int(c / 60)
-    if c >= 0:
-        seconds = int(c % 60)
-    else:
-        seconds = -int(-c % 60)
-    milliseconds = int((c - int(c)) * 1000)
-    return {
-        "hours": hours,
-        "minutes": minutes,
-        "seconds": seconds,
-        "milliseconds": milliseconds,
-    }
-
-
-def split_subtitles(srt_file, invert_commercials, out_file):
-    subs = pysrt.open(srt_file)
-    parts = []
-    prev = 0.0
-    shift = 0
-    for c in invert_commercials:
-        shift = shift - float(c[0]) + prev
-        s = []
-        for i in subs.data:
-            if i.start >= to_time(c[0]) and (c[1] is None or i.start < to_time(c[1])):
-                temp = copy(i)
-                time = to_time(shift)
-                temp.shift(
-                    hours=time["hours"],
-                    minutes=time["minutes"],
-                    seconds=time["seconds"],
-                    milliseconds=time["milliseconds"],
-                )
-                parts.append(temp)
-            else:
-                pass
-            prev = c[1] if c[1] is not None else -1
-    subs = pysrt.SubRipFile(items=parts)
-    subs.save(out_file)
-
-
-def durations_to_invert(durations):
-    ret = []
-    pos = 0
-    for i in durations:
-        ret.append((pos, pos + i))
-        pos = pos + i
-    return ret
-
-
-def create_filename(
-    template, series, season, episode_num, episode_name, filename, extension
-):
-    t = Template(content=template, delimiters=("${", "}"), namespace=create_namespace())
-    d = dict(
-        series=series,
-        season=season,
-        episode=episode_num,
-        episode_name=episode_name,
-        ext=extension,
-        orig_basename=filename,
-    )
-    return t.substitute(d)
diff --git a/media_management_scripts/silver_tube/wtv.py b/media_management_scripts/silver_tube/wtv.py
deleted file mode 100644
index 5093a1e..0000000
--- a/media_management_scripts/silver_tube/wtv.py
+++ /dev/null
@@ -1,24 +0,0 @@
-import os
-from media_management_scripts.utils import create_metadata_extractor
-
-ORIGINAL_BROADCAST_DATE_KEY = "WM/MediaOriginalBroadcastDateTime"
-
-
-def extract_original_air_date(wtv_file, parse_from_filename=True, metadata=None):
-    if metadata is None:
-        metadata = create_metadata_extractor().extract(wtv_file)
-    # WM/MediaOriginalBroadcastDateTime=2012-10-13T04:00:00Z
-    air_date = None
-
-    if ORIGINAL_BROADCAST_DATE_KEY in metadata.tags:
-        air_date = metadata.tags[ORIGINAL_BROADCAST_DATE_KEY]
-    if air_date is None or air_date == "0001-01-01T00:00:00Z":
-        # Extract from filename
-        if parse_from_filename:
-            split = os.path.basename(wtv_file).split("_")
-            air_date = split[2] + "-" + split[3] + "-" + split[4]
-        else:
-            air_date = None
-    else:
-        air_date = air_date.split("T")[0]
-    return air_date
diff --git a/media_management_scripts/silver_tube/wtv_db.py b/media_management_scripts/silver_tube/wtv_db.py
deleted file mode 100644
index 72b0d46..0000000
--- a/media_management_scripts/silver_tube/wtv_db.py
+++ /dev/null
@@ -1,282 +0,0 @@
-import logging
-from sqlalchemy.ext.declarative import declarative_base
-
-Base = declarative_base()
-from sqlalchemy import create_engine
-from sqlalchemy import Column, Integer, String, Date, ForeignKey, Boolean, Text
-from sqlalchemy.orm import sessionmaker, relationship
-import os
-from datetime import date, datetime
-import sys
-
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-def is_int(s):
-    try:
-        int(s)
-        return True
-    except ValueError:
-        return False
-
-
-def input_int(msg):
-    while True:
-        i = input(msg)
-        if is_int(i) and int(i) >= 0:
-            return i
-        elif i == "q":
-            return None
-        else:
-            print("Invalid input, please try again")
-
-
-class Series(Base):
-    __tablename__ = "series"
-
-    id = Column(Integer, primary_key=True)
-    name = Column(String(128), unique=True)
-
-    def __repr__(self):
-        return "Series[Id={}, Name={}]".format(self.id, self.name)
-
-
-class CandidateEpisode(Base):
-    __tablename__ = "candidate_episode"
-
-    id = Column(Integer, primary_key=True)
-    name = Column(String(128))
-    description = Column(Text)
-    air_date = Column(Date)
-    season = Column(Integer)
-    episode_num = Column(Integer)
-    series_id = Column(Integer, ForeignKey("series.id"))
-    series = relationship("Series")
-
-    wtv_file_id = Column(Integer, ForeignKey("wtv_file.filename"))
-    wtv_file = relationship("WtvFile", back_populates="candidate_episodes")
-
-    def get_details(self):
-        padded_season = (
-            str(self.season) if self.season >= 10 else "0" + str(self.season)
-        )
-        padded_episode_num = (
-            str(self.episode_num)
-            if self.episode_num >= 10
-            else "0" + str(self.episode_num)
-        )
-        return "{} - s{}e{} - {}".format(
-            self.series.name, padded_season, padded_episode_num, self.name
-        )
-
-    def __repr__(self):
-        return (
-            "Episode[id={}, series={}, name={}, air_date={}, season={}, num={}]".format(
-                self.id,
-                self.series.name,
-                self.name,
-                self.air_date,
-                self.season,
-                self.episode_num,
-            )
-        )
-
-
-class WtvFile(Base):
-    __tablename__ = "wtv_file"
-
-    filename = Column(String(256), primary_key=True)
-    description = Column(Text)
-    series_id = Column(Integer, ForeignKey("series.id"))
-    series = relationship("Series")
-    candidate_episodes = relationship("CandidateEpisode", cascade="all, delete-orphan")
-    selected_episode = relationship(
-        "SelectedEpisode",
-        back_populates="wtv_file",
-        uselist=False,
-        cascade="all, delete-orphan",
-    )
-
-
-class SelectedEpisode(Base):
-    __tablename__ = "selected_episode"
-
-    # id = Column(Integer, primary_key=True)
-    episode_id = Column(Integer, ForeignKey("candidate_episode.id"), nullable=False)
-    episode = relationship("CandidateEpisode", uselist=False)
-    wtv_file_id = Column(
-        String(256), ForeignKey("wtv_file.filename"), nullable=False, primary_key=True
-    )
-    wtv_file = relationship("WtvFile", uselist=False, back_populates="selected_episode")
-
-
-class WtvDb:
-    def __init__(self, db_file):
-        if ":memory:" == db_file:
-            self._engine = create_engine("sqlite:///:memory:", echo=False)
-        else:
-            path = os.path.abspath(db_file)
-            self._engine = create_engine("sqlite:///" + path, echo=False)
-        Base.metadata.create_all(self._engine)
-        self._Session = sessionmaker(bind=self._engine)
-        self._session = None
-
-    def begin(self):
-        if self._session:
-            self._session.close()
-        self._session = self._Session()
-
-    def end(self):
-        self._session.close()
-        self._session = None
-
-    def _check_session(self):
-        if self._session is None:
-            raise Exception("Session is None. Call begin()")
-
-    def store_candidates(self, tvdb, wtv_filename, meta, episodes):
-        self._check_session()
-        series_name = meta.tags.get("Title", None)
-        series_id = tvdb.get_series_id(series_name)
-        if series_id:
-            series = self.get_or_create_series(series_id, series_name)
-            candidates = [self.from_tvdb(series, e) for e in episodes]
-            wtv_file = WtvFile(
-                filename=wtv_filename,
-                description=meta.tags.get("WM/SubTitleDescription", None),
-                series=series,
-            )
-            wtv_file = self._session.merge(wtv_file)
-            wtv_file.candidate_episodes = candidates
-            self._session.commit()
-        else:
-            logger.warning("No series: {}".format(series_name))
-
-    def from_tvdb(self, series, e):
-        self._check_session()
-        return self._session.merge(
-            CandidateEpisode(
-                id=int(e["id"]),
-                name=e["episodeName"],
-                description=e["overview"],
-                air_date=datetime.strptime(e["firstAired"], "%Y-%m-%d").date(),
-                season=int(e["airedSeason"]),
-                episode_num=int(e["airedEpisodeNumber"]),
-                series=series,
-            )
-        )
-
-    def get_or_create_series(self, series_id, series_name) -> Series:
-        self._check_session()
-        series = self._session.query(Series).get(series_id)
-        if not series:
-            series = Series(id=series_id, name=series_name)
-            self.save(series)
-        return series
-
-    def save(self, obj):
-        self._check_session()
-        self._session.add(obj)
-        self._session.commit()
-
-    def find_series(self, series_name) -> Series:
-        self._check_session()
-        query = self._session.query(Series).filter(Series.name == series_name)
-        return query.one_or_none()
-
-    def get_selected_episode(self, wtv_filename) -> CandidateEpisode:
-        self._check_session()
-        query = self._session.query(WtvFile).filter(WtvFile.filename == wtv_filename)
-        wtv = query.one_or_none()
-        if wtv and wtv.selected_episode:
-            return wtv.selected_episode.episode
-        else:
-            return None
-
-    def get_wtv(self, filename) -> WtvFile:
-        self._check_session()
-        return self._session.query(WtvFile).get(filename)
-
-    def delete_wtv(self, filename):
-        self._check_session()
-        wtv_file = self.get_wtv(filename)
-        if wtv_file:
-            self._session.delete(wtv_file)
-            self._session.commit()
-        else:
-            raise Exception("File not found: {}".format(filename))
-
-    def resolve_all(self, skip_no_options):
-        query = self._session.query(WtvFile).order_by(WtvFile.filename).all()
-        for wtv_file in query:
-            if not skip_no_options or len(wtv_file.candidate_episodes) > 0:
-                print()
-                if self.resolve(wtv_file):
-                    return
-
-    def custom_season_episode(self, wtv_file):
-        season = input_int("Enter Season: ")
-        if season is None:
-            return None
-        episode = input_int("Enter Episode Number: ")
-        if episode is None:
-            return None
-        candidate_episode = CandidateEpisode(
-            episode_num=episode,
-            season=season,
-            name="Episode #{}".format(episode),
-            series=wtv_file.series,
-            wtv_file=wtv_file,
-        )
-        self.save(candidate_episode)
-        self.save(SelectedEpisode(episode=candidate_episode, wtv_file=wtv_file))
-
-    def resolve(self, wtv_file):
-        while True:
-            print("----------------------------------------")
-            print(wtv_file.filename)
-            print(wtv_file.description)
-            print()
-            print("Options:")
-            count = 1
-            for ep in wtv_file.candidate_episodes:
-                selected = ""
-                if (
-                    wtv_file.selected_episode
-                    and wtv_file.selected_episode.episode == ep
-                ):
-                    selected = "*"
-                print("  {}{}) ".format(selected, count), end="")
-                print(ep.get_details())
-                print("     Air Date: {}".format(ep.air_date))
-                print("     {}".format(ep.description))
-                count += 1
-            print("  {}{}) Custom Season/Episode".format("", count))
-            selection = input("Selection: ")
-            if selection == "q":
-                return True
-            elif selection == "":
-                return False
-            elif is_int(selection):
-                s = int(selection)
-                if 0 < s < count:
-                    if wtv_file.selected_episode:
-                        wtv_file.selected_episode.episode = wtv_file.candidate_episodes[
-                            s - 1
-                        ]
-                        self.save(wtv_file)
-                    else:
-                        self.save(
-                            SelectedEpisode(
-                                episode=wtv_file.candidate_episodes[s - 1],
-                                wtv_file=wtv_file,
-                            )
-                        )
-                elif s == count:
-                    self.custom_season_episode(wtv_file)
-                else:
-                    print("Invalid input")
-            else:
-                print("Invalid input")
diff --git a/media_management_scripts/support/executables.py b/media_management_scripts/support/executables.py
index a6bcc55..62d5954 100644
--- a/media_management_scripts/support/executables.py
+++ b/media_management_scripts/support/executables.py
@@ -215,7 +215,7 @@ def execute_with_callback(
                 continue
             try:
                 if l:
-                    l = l.decode("utf-8")
+                    l = l.decode("utf-8", errors="ignore")
                     if l == "\n" or l == "\r":
                         callback(output.getvalue())
                         output = StringIO()
diff --git a/media_management_scripts/support/movie_rename.py b/media_management_scripts/support/movie_rename.py
index 0c92645..2e75fd0 100644
--- a/media_management_scripts/support/movie_rename.py
+++ b/media_management_scripts/support/movie_rename.py
@@ -2,10 +2,8 @@
 from shutil import move
 from dialog import Dialog
 
-from paramiko import Transport, RSAKey
 import os
 from difflib import SequenceMatcher
-from scp import SCPClient
 from media_management_scripts.support.formatting import sizeof_fmt
 from media_management_scripts.utils import create_metadata_extractor
 
@@ -13,37 +11,6 @@
 CANCEL = 1
 
 
-def _transfer(
-    result: NameInformation, input_file, username, pkey_file, host, output_path
-):
-    output_file = os.path.join(output_path, os.path.basename(input_file))
-    pkey = RSAKey.from_private_key_file(filename=pkey_file)
-    with Transport((host, 22)) as transport:
-        transport.connect(username=username, pkey=pkey)
-
-        filename = os.path.basename(output_file)
-        d = Dialog(autowidgetsize=False)
-        d.gauge_start(
-            title=result.simple_name,
-            text="Transferring...\n{}".format(filename),
-            percent=0,
-        )
-        try:
-
-            def callback(file, m, curr):
-                current = sizeof_fmt(curr)
-                max = sizeof_fmt(m)
-                text = "Transferring...\n{}\n{} of {}".format(filename, current, max)
-                d.gauge_update(percent=int(curr / m * 100), text=text, update_text=True)
-
-            with SCPClient(
-                transport, buff_size=2 * 1024 * 1024, progress=callback
-            ) as client:
-                client.put(input_file, output_file)
-        finally:
-            d.gauge_stop()
-
-
 def _search(title, file, metadata):
     results = MovieDbApi().search_title(title, metadata)
     # Sort by closeness to file's title, then title, then year
@@ -98,32 +65,10 @@ def movie_rename(input_to_cmd, ns):
     dry_run = ns.get("dry_run", False)
     results = [(i, _get_new_name(i)) for i in input_to_cmd]
     if results:
-        username = ns.get("username", None)
-        host = ns.get("host", None)
-        pkey_file = ns.get("pkey", None)
-        output_path = ns.get("output_path", None)
-        move_source = ns.get("move_source_path", None)
         for original, result in results:
             if result:
                 new_file = result.new_name(original)
                 if not dry_run:
-                    if not host or not pkey_file or not output_path:
-                        print(
-                            "If not using dry-run, you must include the host, pkey, and output path"
-                        )
-                    else:
-                        move(original, new_file)
-                        _transfer(
-                            result, new_file, username, pkey_file, host, output_path
-                        )
-                        if move_source:
-                            new_loc = os.path.join(
-                                move_source, os.path.basename(new_file)
-                            )
-                            dir = os.path.dirname(new_file)
-                            move(new_file, new_loc)
-                            if len(os.listdir(dir)) == 0:
-                                os.rmdir(dir)
-
+                    move(original, new_file)
                 else:
                     print(new_file)
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..7bd38a1
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,52 @@
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = [
+    "setuptools",
+    "setuptools-git-versioning",
+    "wheel"
+]
+
+[tool.setuptools]
+zip-safe = false
+license-files = ["LICENSE"]
+
+[tool.setuptools-git-versioning]
+enabled = true
+
+[project]
+name = "media-management-scripts"
+description = "Media Management Scripts"
+dynamic = ["version"]
+readme = { file = "README.md", content-type = "text/markdown" }
+authors = [
+    { name = "Ray Douglass" },
+]
+license = { text = "Apache 2.0" }
+requires-python = ">=3.9"
+dependencies = [
+  "requests",
+  "pyOpenSSL",
+  "texttable",
+  "tmdbsimple",
+  "argcomplete",
+  "tempita",
+  "pysrt",
+  "pythondialog",
+  "pyyaml",
+  "pyparsing",
+  "pycaption",
+  "python-magic",
+]
+classifiers = [
+  "License :: OSI Approved :: Apache Software License",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3",
+]
+
+[project.scripts]
+manage-media = "media_management_scripts.main:main"
+convert-dvds = "media_management_scripts.convert_daemon:main"
+tvdb-api = "media_management_scripts.tvdb_api:main"
+
+[project.urls]
+Homepage = "https://github.com/raydouglass/media_management_scripts"
diff --git a/sample.ini b/sample.ini
index 93e5820..705f53d 100644
--- a/sample.ini
+++ b/sample.ini
@@ -34,4 +34,4 @@ deinterlace_threshold = .5
 [logging]
 level = DEBUG
 file = convert.log
-db = processed.shelve
\ No newline at end of file
+db = processed.shelve
diff --git a/setup.py b/setup.py
deleted file mode 100644
index 750aa34..0000000
--- a/setup.py
+++ /dev/null
@@ -1,43 +0,0 @@
-from setuptools import setup
-
-from media_management_scripts import version
-
-with open("README.md", "r") as fh:
-    long_description = fh.read()
-
-setup(
-    name="media_management_scripts",
-    version=version,
-    description="Scripts for managing media",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    url="https://github.com/raydouglass/media_management_scripts",
-    author="Ray Douglass",
-    author_email="ray@raydouglass.com",
-    license="Apache",
-    packages=[
-        "media_management_scripts",
-        "media_management_scripts.commands",
-        "media_management_scripts.silver_tube",
-        "media_management_scripts.support",
-    ],
-    zip_safe=False,
-    scripts=["bin/manage-media", "bin/convert-dvds", "bin/silver-tube", "bin/tvdb-api"],
-    install_requires=[
-        "requests",
-        "pyOpenSSL",
-        "texttable",
-        "tmdbsimple",
-        "argcomplete",
-        "tempita",
-        "SQLAlchemy",
-        "pysrt",
-        "paramiko",
-        "scp",
-        "pythondialog",
-        "pyyaml",
-        "pyparsing",
-        "pycaption",
-        "python-magic",
-    ],
-)
diff --git a/tests/comskip.ini b/tests/comskip.ini
index 58da04f..5e5a1f3 100644
--- a/tests/comskip.ini
+++ b/tests/comskip.ini
@@ -75,4 +75,4 @@ dvrcut_options="dvrcut \"%s.dvr-ms\" \"%s_clean.dvr-ms\" "
 windowtitle="Comskip - %s"
 output_dvrmstb=1
 dvrmsstandoff=120000
-output_plist_cutlist=0
\ No newline at end of file
+output_plist_cutlist=0
diff --git a/tests/test_logging.yaml b/tests/test_logging.yaml
index d0fa642..e71187a 100644
--- a/tests/test_logging.yaml
+++ b/tests/test_logging.yaml
@@ -13,4 +13,4 @@ handlers:
 
 root:
     level: INFO
-    handlers: [console]
\ No newline at end of file
+    handlers: [console]
diff --git a/tests/test_silver_tube.py b/tests/test_silver_tube.py
deleted file mode 100644
index f23a01d..0000000
--- a/tests/test_silver_tube.py
+++ /dev/null
@@ -1,215 +0,0 @@
-import unittest
-from tempfile import TemporaryDirectory, NamedTemporaryFile
-import configparser
-from media_management_scripts.support.encoding import DEFAULT_CRF, DEFAULT_PRESET
-from media_management_scripts.support.executables import ccextractor, comskip
-import os
-from media_management_scripts.support.encoding import (
-    Resolution,
-    VideoCodec,
-    VideoFileContainer,
-    AudioCodec,
-    AudioChannelName,
-)
-from tests import create_test_video, VideoDefinition, LOG_FILE
-from unittest import mock
-
-from media_management_scripts.silver_tube.processing import Configuration
-from media_management_scripts.tvdb_api import TVDB
-
-WTV_VIDEO_DEF = VideoDefinition(
-    resolution=Resolution.STANDARD_DEF,
-    codec=VideoCodec.MPEG2,
-    container=VideoFileContainer.WTV,
-)
-
-try:
-    comskip()
-    comskip_installed = True
-except:
-    comskip_installed = False
-
-
-@unittest.skipUnless(comskip_installed, reason="Need comskip to run these tests")
-class SilverTubeTestCase(unittest.TestCase):
-    def setUp(self):
-        self.files = []
-        self.dirs = []
-        self.config_file = NamedTemporaryFile(suffix=".ini", delete=False, mode="w")
-        db_file = NamedTemporaryFile(suffix=".sqlite3")
-
-        config = configparser.ConfigParser()
-        config["main"] = {
-            "debug": False,
-            "database.file": db_file.name,
-            "log.config": LOG_FILE,
-        }
-        self.tv_in = TemporaryDirectory()
-        self.commercial_in = TemporaryDirectory()
-        self.srt_in = TemporaryDirectory()
-        self.temp_dir = TemporaryDirectory()
-        self.out_dir = TemporaryDirectory()
-        config["directories"] = {
-            "tv.in": self.tv_in.name,
-            "commercial.in": self.commercial_in.name,
-            "srt.in": self.srt_in.name,
-            "temp.dir": self.temp_dir.name,
-            "out.dir": self.out_dir.name,
-            "tv.pattern": "*.wtv",
-        }
-        config["transcode"] = {
-            "preset": DEFAULT_PRESET,
-            "crf": DEFAULT_CRF,
-            "bitrate": "auto",
-        }
-        config["ccextractor"] = {"executable": ccextractor(), "run.if.missing": True}
-        comskip_ini = os.path.join(
-            os.path.dirname(os.path.realpath(__file__)), "comskip.ini"
-        )
-        config["comskip"] = {
-            "executable": comskip(),
-            "comskip.ini": comskip_ini,
-            "run.if.missing": True,
-        }
-        self.files.extend([self.config_file, db_file])
-        self.dirs.extend(
-            [self.tv_in, self.commercial_in, self.srt_in, self.temp_dir, self.out_dir]
-        )
-        with self.config_file:
-            config.write(self.config_file)
-
-    def tearDown(self):
-        for f in self.files:
-            f.close()
-            if os.path.exists(f.name):
-                os.unlink(f.name)
-        for d in self.dirs:
-            d.cleanup()
-
-    def test_config_file_created(self):
-        parser = configparser.ConfigParser()
-        parser.read(self.config_file.name)
-        self.assertEqual(
-            ccextractor(), parser.get("ccextractor", "executable", fallback=None)
-        )
-
-    @mock.patch("media_management_scripts.tvdb_api.TVDB")
-    def test_no_files(self, tvdb_mock):
-        config = Configuration(self.config_file.name, tvdb_mock)
-        config.run()
-        self.assertEqual(0, config.count)
-
-    @mock.patch("media_management_scripts.tvdb_api.TVDB")
-    def test_basic(self, tvdb_mock):
-        tvdb_mock.find_episode.return_value = [
-            {
-                "id": 1001,
-                "episodeName": "Test Episode NameTVDB",
-                "overview": "TheOverview",
-                "firstAired": "2011-01-01",
-                "airedSeason": 2,
-                "airedEpisodeNumber": 3,
-            }
-        ]
-        tvdb_mock.season_number = lambda e: (e["airedSeason"], e["airedEpisodeNumber"])
-        meta = {
-            "Title": "TheSeries",
-            "WM/SubTitle": "Test Episode Name",
-            "WM/SubTitleDescription": "TheSubTitleDescription",
-            "WM/MediaOriginalBroadcastDateTime": "2011-01-01T00:00:00Z",
-        }
-        input_file = os.path.join(self.tv_in.name, "test.wtv")
-        create_test_video(
-            length=10, video_def=WTV_VIDEO_DEF, output_file=input_file, metadata=meta
-        )
-        os.utime(input_file, (0, 0))
-        config = Configuration(self.config_file.name, tvdb_mock)
-        config.run()
-        self.assertEqual(1, config.count)
-
-        expected_file = os.path.join(
-            self.out_dir.name,
-            "TheSeries/Season 2/TheSeries - S02E03 - Test Episode NameTVDB.mp4",
-        )
-        self.assertTrue(os.path.isfile(expected_file))
-
-    @mock.patch("media_management_scripts.tvdb_api.TVDB")
-    def test_store_candidates(self, tvdb_mock):
-        tvdb_mock.find_episode.return_value = [
-            {
-                "id": 1001,
-                "episodeName": "Test Episode NameTVDB",
-                "overview": "TheOverview",
-                "firstAired": "2011-01-01",
-                "airedSeason": 2,
-                "airedEpisodeNumber": 3,
-            },
-            {
-                "id": 1002,
-                "episodeName": "Test Episode NameTVDB2",
-                "overview": "TheOverview2",
-                "firstAired": "2011-01-02",
-                "airedSeason": 2,
-                "airedEpisodeNumber": 4,
-            },
-        ]
-        tvdb_mock.season_number = lambda e: (e["airedSeason"], e["airedEpisodeNumber"])
-        tvdb_mock.get_series_id.return_value = 54321
-        meta = {
-            "Title": "TheSeries",
-            "WM/SubTitle": "Test Episode Name",
-            "WM/SubTitleDescription": "TheSubTitleDescription",
-            "WM/MediaOriginalBroadcastDateTime": "2011-01-01T00:00:00Z",
-        }
-        input_file = os.path.join(self.tv_in.name, "test.wtv")
-        create_test_video(
-            length=10, video_def=WTV_VIDEO_DEF, output_file=input_file, metadata=meta
-        )
-        os.utime(input_file, (0, 0))
-        config = Configuration(self.config_file.name, tvdb_mock)
-        config.run()
-        self.assertEqual(1, config.count)
-
-        expected_file = os.path.join(
-            self.out_dir.name,
-            "TheSeries/Season 2/TheSeries - S02E03 - Test Episode NameTVDB.mp4",
-        )
-        self.assertFalse(os.path.isfile(expected_file))
-
-        config.wtvdb.begin()
-        wtv = config.wtvdb.get_wtv("test.wtv")
-        self.assertIsNotNone(wtv)
-        self.assertEqual(2, len(wtv.candidate_episodes))
-        config.wtvdb.end()
-
-    @mock.patch("media_management_scripts.tvdb_api.TVDB")
-    def test_no_candidates(self, tvdb_mock):
-        tvdb_mock.find_episode.return_value = []
-        tvdb_mock.season_number = lambda e: (e["airedSeason"], e["airedEpisodeNumber"])
-        tvdb_mock.get_series_id.return_value = 54321
-        meta = {
-            "Title": "TheSeries",
-            "WM/SubTitle": "Test Episode Name",
-            "WM/SubTitleDescription": "TheSubTitleDescription",
-            "WM/MediaOriginalBroadcastDateTime": "2011-01-01T00:00:00Z",
-        }
-        input_file = os.path.join(self.tv_in.name, "test.wtv")
-        create_test_video(
-            length=10, video_def=WTV_VIDEO_DEF, output_file=input_file, metadata=meta
-        )
-        os.utime(input_file, (0, 0))
-        config = Configuration(self.config_file.name, tvdb_mock)
-        config.run()
-        self.assertEqual(1, config.count)
-
-        expected_file = os.path.join(
-            self.out_dir.name,
-            "TheSeries/Season 2/TheSeries - S02E03 - Test Episode NameTVDB.mp4",
-        )
-        self.assertFalse(os.path.isfile(expected_file))
-
-        config.wtvdb.begin()
-        wtv = config.wtvdb.get_wtv("test.wtv")
-        self.assertIsNotNone(wtv)
-        self.assertEqual(0, len(wtv.candidate_episodes))
-        config.wtvdb.end()