p3-tv 0.9.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c3d630bf9e9b81457b1d57e3baba1358c849611b
+  data.tar.gz: 8ff50ded8f3818818acd36aae020d9f58c0ccc51
+SHA512:
+  metadata.gz: 56ee639f934ff4761867beaad17e76781e495be16e6f9c28365ee5b0826433ec510f30ac3b037a3906947d55fc2a7d434048332dbb8f0d63bffa5a9e50cb4dbf
+  data.tar.gz: 6ac0f51ef743fb84b49c1715b6c3a7f5cc0e957b59a89feea4992fcbb44c76443b16afd2cb0eeafadb8a3917076b07df552a95abb1c9931c82e1394527f9cfb4

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in p3-tv.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Poul Hornsleth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+# P3TV
+[![Gem Version](https://badge.fury.io/rb/p3-tv.svg)](http://badge.fury.io/rb/p3-tv)
+
+Organize and rename your TV Shows. Automatically find links to missing shows. Includes Command-Line Utility
+
+## Installation
+    $ sudo gem install p3-tv
+
+## Usage
+
+Run 'p3tv' at the command prompt and choose from the menu
+
+    $ p3tv
+    1. Search for TV Series
+    2. List TV Series
+    3. Download Missing Episodes
+    4. Catalog Downloads
+    5. Manage Directories
+    6. Test Mode
+    7. quit
+    What do you want to do?
+
+
+## Development Usage
+
+Fetch a series and get all the magnet links:
+```ruby
+require 'p3-tv'
+
+P3::TV::Settings::create_default! unless P3::TV::Settings::exists?
+P3::TV::add_series!( "Black Sails" )
+P3::TV::enable_test_mode!( true )
+
+P3::TV::catalog_downloads!
+P3::TV::download_missing!
+
+```
+
+
+## Contributing
+
+1. Fork it.
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/bin/p3tv

@@ -0,0 +1,130 @@
+#!/usr/bin/ruby
+
+require 'highline'
+require 'p3-tv'
+Encoding.default_external = 'UTF-8'
+
+# Basic usage
+
+Signal::trap("INT") do
+    exit
+end
+
+Signal::trap("TERM") do
+    exit
+end
+
+
+P3::TV::Settings::create_default! unless P3::TV::Settings::exists?
+
+
+cli = HighLine.new
+
+begin
+    settings = P3::TV::Settings.new
+
+    cli.say("\n")
+    cli.say("\n")
+    cli.say("\n")
+
+    cli.choose do | main_menu |
+
+        main_menu.prompt = "What do you want to do?"
+
+
+        main_menu.choice("Catalog Downloads") do
+            confirm = cli.ask("This command will move any episodes from your download dir to your Library. Are you sure? [Y/N] ") { |yn| yn.limit = 1, yn.validate = /[yn]/i }
+            P3::TV::catalog_downloads!( settings ) if confirm.downcase == 'y'
+        end
+
+
+
+        main_menu.choice("Download Missing Episodes") do
+            confirm = cli.ask("This command will open any missing magnet links. Are you sure? [Y/N]") { |yn| yn.limit = 1, yn.validate = /[yn]/i }
+            P3::TV::download_missing!( settings ) if confirm.downcase == 'y'
+        end
+
+
+        main_menu.choice("Manage Series") do
+            cli.choose do | series_menu |
+                series_menu.choice("Add Series") do
+                    title = cli.ask "What series would you like to search for?"
+                    search = P3::TV::Search.new( settings )
+                    results = search.find_series( title )
+                    cli.choose do | results_menu |
+                        results_menu.prompt = "Which series would you like to add?"
+                        results.each do | series |
+                            results_menu.choice( series.name + ' : ' + series.network ) do
+                                settings.add_series!( series )
+                                settings.save!
+                            end
+                        end
+                        results_menu.choice( "cancel" ) do
+                        end
+                    end
+                end
+
+                series_menu.choice("Delete Series") do
+
+                    cli.choose do | delete_menu |
+                        delete_menu.prompt = "Which series would you like to delete?"
+                        settings[:series].each do | series |
+                            delete_menu.choice( series[:name] + ' : ' + series[:network] ) do
+                                confirm = cli.ask("Are you sure? [Y/N]") { |yn| yn.limit = 1, yn.validate = /[yn]/i }
+                                settings.remove_series!( series[:id] ) if confirm.downcase == 'y'
+                                settings.save!
+                            end
+                        end
+
+                        delete_menu.choice( "cancel" ) do
+                        end
+                    end
+                end
+
+                series_menu.choice("List TV Series") do
+                    settings[:series].each do | series |
+                        cli.say( series[:name] + ' : ' + series[:network] )
+                    end
+                end
+
+            end
+        end
+
+
+        main_menu.choice("Manage Directories") do
+            cli.choose do | dir_menu |
+                {:library_path => 'Library', :download_path => 'Download' }.each do | k, v |
+                    dir_menu.choice( "Update #{v} Path" ) do
+                        path = cli.ask('Enter New Path')
+                        P3::TV::Settings::set!( k, path )
+                    end
+                    dir_menu.choice( "Open #{v} Path" ) do
+                        cmd = "open '#{settings[k]}'"
+                        puts cmd
+                        system( cmd )
+                    end
+                end
+                dir_menu.choice( "cancel" ) do
+                end
+            end
+        end
+
+
+        main_menu.choice("Toggle Test Mode ( Currently #{P3::TV::test_mode_enabled? ? 'Enabled' : 'Disabled'} )") do
+            P3::TV::enable_test_mode!( !P3::TV::test_mode_enabled? )
+        end
+
+        main_menu.choice("Set TVDB API Key ( #{settings[:tvdb_api_key] or 'Not Set'} )") do
+            tvdb_api_key = cli.ask('Enter TVDB API Key ( http://www.thetvdb.com/?tab=register )')
+            P3::TV::Settings::set!(:tvdb_api_key, tvdb_api_key )
+        end
+
+        main_menu.choice("Reload Settings") do
+            puts "reloaded" # will be reloaded on next loop
+        end
+
+        main_menu.choice("quit") do
+            exit(0)
+        end
+    end
+end while true

data/bin/p3tv_json_api

@@ -0,0 +1,56 @@
+#!/usr/bin/ruby
+
+require 'p3-tv'
+Encoding.default_external = 'UTF-8'
+
+P3::TV::Settings::create_default! unless P3::TV::Settings::exists?
+
+settings = P3::TV::Settings.new
+
+case ARGV[0]
+when 'set_tvdb_api_key'
+    settings[:tvdb_api_key] = ARGV[1]
+when 'settings'
+    puts settings.to_h.to_json
+when 'search'
+    search = P3::TV::Search.new( settings )
+    results = search.find_series( ARGV[1] )
+    results = results.collect{|r| r.to_h }
+    puts results.to_json
+when 'add_series'
+    search = P3::TV::Search.new( settings )
+    series = search.find_series_by_id( ARGV[1] )
+    settings.add_series!( series ) if series
+when 'remove_series'
+    search = P3::TV::Search.new( settings )
+    series = search.find_series_by_id( ARGV[1] )
+    settings.remove_series!( series.id ) if series
+when 'episode_status'
+    search = P3::TV::Search.new( settings )
+    library = P3::TV::Library.new( settings )
+    downloads = P3::TV::Downloads.new( settings )
+    files = []
+    settings.each_series_episode_file_status( ARGV[1], search, downloads, library ) do | episode_file |
+        files << episode_file.to_h
+    end
+    puts files.to_json
+when 'download_missing'
+    P3::TV::download_missing_series!( ARGV[1], settings )
+when 'catalog_and_downloads'
+    downloads = P3::TV::Downloads.new( settings )
+
+    if( downloads.remove_completed_torrents! > 0 )
+        P3::TV::catalog_downloads!( settings, downloads )
+    end
+
+    files = []
+    downloads.each_downloading_file do | episode_file |
+        files << episode_file.to_h
+    end
+    files.sort!{|a,b| b[:percent_done] <=> a[:percent_done] } #highest percent first
+    puts files.to_json
+when 'catalog_downloads_for_series'
+    P3::TV::catalog_downloads_series!( ARGV[1], settings )
+when 'catalog_downloads'
+    P3::TV::catalog_downloads!( settings )
+end

data/lib/p3-tv.rb

@@ -0,0 +1,643 @@
+require 'fileutils'
+require 'json'
+require 'open-uri'
+
+require 'p3-eztv'
+require 'p3-tvdb'
+require 'p3-transmission'
+
+module P3
+    module TV
+
+	class Settings
+	    attr_accessor :path
+	    DEPRECATED_PATH = File::expand_path( "~/.p3tv" )
+	    DEFAULT_PATH = File::expand_path( "~/.p3tv/p3tv" )
+	    EPISODES_JSON = 'episodes.json'
+	    DEFAULTS = {
+		:library_path => '~/Movies',
+		:download_path => '~/Downloads',
+                :create_p3tv_dir => true,
+		:delete_duplicate_downloads => false,
+		:overwrite_duplicates => false,
+		:allowed_types => ['.avi', '.mkv', '.mp4'],
+		:language => 'en',
+		:subtitles => ['.srt'],
+		:high_def => true,
+		:verbose => false,
+		:dry_run => false,
+		:series => []
+	    }
+
+	    def self.exists?( path = DEFAULT_PATH )
+		if( File::directory?( DEPRECATED_PATH ) )
+		    return File::exists?( path )
+		else
+		    if( File::exists?( DEPRECATED_PATH ) )
+			puts "please move your settings file #{DEPRECATED_PATH} to #{DEFAULT_PATH}"
+			return false
+		    end
+		end
+	    end
+
+	    def self.create_default!( path = DEFAULT_PATH )
+		raise "a settings file already exists. please delete #{path} first" if exists?( path )
+
+		FileUtils::mkdir_p( File::dirname( path ) )
+		settings = Settings.new( path )
+		DEFAULTS.each do | key, value |
+		    settings[ key ] = value
+		end
+		settings.save!
+	    end
+
+	    def self.set!( key, value, path = DEFAULT_PATH )
+		settings = Settings.new( path )
+		settings[ key ] = value
+		settings.save!
+	    end
+
+	    def initialize( path = DEFAULT_PATH )
+		@path = path
+		@values = {}
+		@episodes = {}
+		return unless File::exists?( @path )
+
+		FileUtils::mkdir_p( File::dirname( @path ) )
+
+		f = File::open( @path, 'r' )
+		@values = JSON::parse( f.read, :symbolize_names => true )
+		f.close
+
+		self[:library_path] = File::join( self[:library_path], "P3TV" ) if self[:create_p3tv_dir ]
+		self[:library_path] = File::expand_path( self[:library_path ] )
+		self[:download_path] = File::expand_path( self[:download_path ] )
+		self[:series].uniq!
+
+		if( self[:overwrite_duplicates] and self[:delete_duplicate_downloads] )
+		    raise "you cannot have 'overwrite_duplicates' and 'delete_duplicate_downloads' both set to true"
+		end
+
+	    end
+
+	    def to_h
+		return @values
+	    end
+
+	    def []( key )
+		return @values[ key ]
+	    end
+
+	    def []=( key, value )
+		@values[ key ] = value
+		self.save!
+	    end
+
+	    def allowed_type?( path )
+		return ( self[:allowed_types].include?( File::extname( path ) ) or self[:subtitles].include?( File::extname( path ) ) )
+	    end
+
+	    def get_series( seriesid )
+		return self[:series].detect{|s| s[:id] == seriesid }
+	    end
+
+	    def download_url!( url, path )
+		# http://stackoverflow.com/questions/2515931/how-can-i-download-a-file-from-a-url-and-save-it-in-rails
+		return path if File::exists?( path )
+		begin
+		    download = open( url )
+		    IO.copy_stream( download, path )
+		rescue => e
+		    return ""
+		end
+		return path
+	    end
+
+	    def download_banners!( banners, path )
+		FileUtils::mkdir_p( File::dirname( path ) )
+		return if banners.empty?
+		banner = banners.detect{|b| b.url.length }
+		return "" unless banner
+
+		return download_url!( banner.url, path )
+	    end
+
+	    def episodes( seriesid )
+		unless @episodes.has_key?( seriesid )
+		    f = File::open( File::join( series_dir( seriesid ), EPISODES_JSON ) )
+		    @episodes[ seriesid ] = JSON::parse( f.read, :symbolize_names => true )
+		end
+		return @episodes[ seriesid ]
+	    end
+
+	    def each_series_episode_file_status( seriesid, search, downloads, library )
+		today = Date::today.to_s
+
+		series_hash = self[:series].detect{|s| s[:id] == seriesid}
+		return unless series_hash
+
+		episodes( seriesid ).each do | episode_hash |
+		    next if episode_hash[:season_number] == 0
+		    ep_file = P3::TV::EpisodeFile.new
+		    ep_file.series_id = episode_hash[:id]
+		    ep_file.series = series_hash[:name]
+		    ep_file.season = episode_hash[:season_number]
+		    ep_file.episode = episode_hash[:number]
+		    ep_file.title = episode_hash[:name]
+		    ep_file.air_date = episode_hash[:air_date]
+		    ep_file.thumbnail = episode_hash[:thumb_path]
+
+		    if( ( ep_file.air_date == nil ) or ( ep_file.air_date > today ) )
+			ep_file.percent_done = 0
+			ep_file.status = :upcoming
+			ep_file.path = ''
+		    elsif( library.exists?( ep_file ) )
+			ep_file.percent_done = 1
+			ep_file.status = :cataloged
+			ep_file.path = library.episode_path( ep_file )
+		    elsif( download_path = downloads.get_path_if_exists( ep_file ) )
+			ep_file.percent_done = 1
+			ep_file.status = :downloaded
+			ep_file.path = download_path
+		    elsif( torrent = downloads.get_torrent_if_exists( ep_file ) )
+			ep_file.percent_done = torrent['percentDone']
+			ep_file.status = :downloading
+			ep_file.path = ''
+		    elsif( magnet_link = search.get_magnet_link_if_exists( ep_file ) )
+			ep_file.percent_done = 0
+			ep_file.status = :available
+			ep_file.path = magnet_link
+		    else
+			ep_file.percent_done = 0
+			ep_file.status = :missing
+			ep_file.path = ''
+		    end
+		    yield( ep_file )
+		end
+	    end
+
+
+	    def series_dir( seriesid )
+		return File::join( File::dirname( @path ), 'series', seriesid )
+	    end
+
+	    def add_series!( series )
+		hash = series.to_h
+		hash[:banners] = {}
+		meta_path = series_dir( hash[:id] )
+		hash[:banners][:poster] = download_banners!( series.posters( self[:language] ),  File::join( meta_path, 'poster.jpg' ) )
+		hash[:banners][:banner] = download_banners!( series.series_banners( self[:language] ),  File::join( meta_path, 'banner.jpg' ) )
+
+		episodes = []
+		series.episodes.each do |episode|
+		    episode_hash = episode.to_h
+		    episode_hash[:thumb_path] = download_url!( episode_hash[:thumb], File::join( meta_path, "#{episode.id}.jpg" ) )
+		    episodes << episode_hash
+		end
+		f = File::open( File::join( meta_path, EPISODES_JSON ), 'w' )
+		f.puts JSON::pretty_generate( episodes )
+		f.close()
+
+		remove_series!( hash[:id] )
+		self[:series] << hash
+		leading_the = /^The /
+		self[:series].sort!{|a,b| a[:name].gsub(leading_the,'') <=> b[:name].gsub(leading_the,'') }
+		self.save!
+	    end
+
+	    def remove_series!( seriesid )
+		self[:series].reject!{|s| s[:id] == seriesid }
+		self.save!
+	    end
+
+	    def save!
+		f = File::open( @path, 'w' )
+		f.puts( JSON::pretty_generate( @values ) )
+		f.close
+	    end
+	end
+
+	class EpisodeFile
+	    attr_accessor :series_id, :series, :season, :episode, :title, :air_date, :path, :status, :percent_done, :thumbnail
+	    attr_writer :type
+
+	    def type
+		unless @type
+		    if( @path )
+			ext = File::extname( @path )
+			@type = ext unless ext.empty?
+		    end
+		end
+		return @type
+	    end
+
+	    def to_json(*a)
+		return to_h.to_json(*a)
+	    end
+
+	    def to_h
+		return { :series_id => series_id,
+			 :series => series,
+			 :season => season,
+			 :episode => episode,
+			 :title => title,
+			 :air_date => air_date.to_s,
+			 :path => path,
+			 :status => status,
+			 :percent_done => percent_done,
+			 :thumbnail => thumbnail
+		}
+	    end
+
+	    def <=>( other )
+		if( self.series == other.series )
+		    if( self.season == other.season )
+			return self.episode <=> other.episode
+		    else
+			return self.season <=> other.season
+		    end
+		else
+		    return self.series <=> other.series
+		end
+	    end
+
+	    def to_s
+		return to_h.to_s
+	    end
+	end
+
+	class Library
+
+	    def initialize( settings = Settings.new )
+		@settings = settings
+	    end
+
+	    def exists?( episode )
+		Dir::glob( episode_glob( episode ) ).each do | path |
+		    return true if File::exists?( path )
+		end
+		return false
+	    end
+
+	    def format_season( episode )
+		return episode.season.to_s.rjust( 2, '0' )
+	    end
+
+	    def format_episode( episode )
+		return episode.episode.to_s.rjust( 2, '0' )
+	    end
+
+
+	    def episode_glob( episode )
+		formatted_title = P3::TV::format_title( episode.series )
+		return File::join( @settings[:library_path],
+				   formatted_title,
+				   "Season #{format_season( episode )}",
+				   "#{formatted_title} S#{format_season( episode )}E#{format_episode( episode )}" + ( episode.type or '.*' )
+				 )
+	    end
+
+	    def episode_path( episode )
+		glob = episode_glob( episode )
+		if( episode.type )
+		    return glob # this will NOT end in .*
+		else
+		    Dir::glob( glob ).each do | path |
+			return path
+		    end
+		end
+	    end
+
+	    def catalog!( episode )
+		cataloged_path  = episode_path( episode )
+		cataloged_dir = File::dirname( cataloged_path )
+
+		unless File::exists?( cataloged_dir )
+		    FileUtils::mkdir_p( cataloged_dir, { :noop => @settings[:dry_run], :verbose => @settings[:verbose] } )
+		end
+
+		if( !File::exists?( cataloged_path ) or @settings[:overwrite_duplicates] )
+		    FileUtils::move( episode.path, cataloged_path, { :noop => @settings[:dry_run], :verbose => @settings[:verbose], :force => true } )
+		elsif( @settings[:delete_duplicate_downloads] )
+		    FileUtils::remove( episode.path, { :noop => @settings[:dry_run], :verbose => @settings[:verbose] } )
+		else
+		    STDERR.puts "file exists. doing nothing: #{cataloged_path}" if @settings[:verbose]
+		end
+	    end
+	end
+
+	class Downloads
+
+	    REGEX = [ /[sS](\d{1,2})[eE](\d{1,2})/, #s1e2, s01e02, S1E02, S01E2
+		      /(\d{1,2})x(\d{1,2})/ #1x2, 01x2, 1x02, 01x02
+		    ]
+
+	    def initialize( settings = Settings.new )
+		@settings = settings
+		@transmission = nil
+		@paths = nil
+		@torrents = nil
+	    end
+
+	    def path_match_series( path, series_name )
+		return unless( P3::TV::path_contains_series?( path, series_name ) )
+		REGEX.each do | regex |
+		    match_data = path.match( regex )
+		    if( match_data )
+			yield( match_data )
+			return
+		    end
+		end
+	    end
+
+	    def path_match( path )
+		@settings[:series].each do | series |
+		    path_match_series( path, series[:name] ) do | match_data |
+			yield( series, match_data )
+			return
+		    end
+		end
+	    end
+
+	    def create_episode_from_filename_series( path, seriesid, series_name )
+		e = nil
+		path_match_series( path, series_name ) do | match_data |
+		    e = EpisodeFile.new
+		    e.series_id = seriesid
+		    e.series = series_name
+		    e.season = match_data[1].to_i
+		    e.episode = match_data[ 2 ].to_i
+		    e.path = path
+		end
+		return e
+	    end
+
+	    def create_episode_from_filename( path )
+		e = nil
+		path_match( path ) do | series, match_data |
+		    e = EpisodeFile.new
+		    e.series_id = series[:id]
+		    e.series = series[:name]
+		    e.season = match_data[1].to_i
+		    e.episode = match_data[ 2 ].to_i
+		    e.path = path
+		end
+		return e
+	    end
+
+	    def each_episode_file_in_series( seriesid )
+		series = @settings.get_series( seriesid )
+		if( series )
+		    episode_files = paths().collect{|path| create_episode_from_filename_series( path, series[:id], series[:name] ) }
+		    episode_files.each do | episode_file |
+			yield( episode_file ) if episode_file
+		    end
+		end
+	    end
+
+	    def each_episode_file
+		episode_files = paths().collect{|path| create_episode_from_filename( path ) }
+		episode_files.each do | episode_file |
+		    if episode_file
+			episode_file.status = :downloaded
+			episode_file.percent_done = 1
+			yield( episode_file )
+		    end
+		end
+
+	    end
+
+	    def each_downloading_file
+		torrents().each do |torrent|
+		    episode_file = create_episode_from_filename( torrent['name'] )
+		    if( episode_file )
+			episode_file.status = :downloading
+			episode_file.percent_done = torrent['percentDone']
+			yield( episode_file )
+		    end
+		end
+	    end
+
+	    def download!( path )
+		transmission().create( path ) if transmission()
+	    end
+
+	    def download_episode_file!( episode_file )
+		if( episode_file.status == :available )
+		    magnet_link = episode_file.path
+		    puts magnet_link if @settings[:verbose]
+		    unless @settings[:dry_run]
+			download!( magnet_link )
+		    end
+		end
+	    end
+
+	    def paths
+		return @paths if @paths
+		glob = File::join( @settings[:download_path], '**/*' )
+		@paths = Dir::glob( glob )
+		@paths = @paths.select{|p| @settings.allowed_type?( p ) }
+		return @paths
+	    end
+
+	    def transmission
+		unless @transmission
+		    unless( @settings[:transmission] == nil )
+			@transmission = P3::Transmission::Client.new(@settings[:transmission])
+		    end
+		end
+
+		return @transmission
+	    end
+
+	    def torrents
+		@torrents = [] unless transmission()
+		unless @torrents
+		    @torrents = transmission().all
+		end
+
+		return @torrents
+	    end
+
+	    def remove_completed_torrents!
+		count = 0
+		torrents().each do | torrent |
+		    count += 1
+		    transmission().remove( torrent['id'] ) if torrent['percentDone'] == 1
+		end
+
+		torrents().reject!{ | torrent | torrent['percentDone'] == 1 }
+		return count
+	    end
+
+	    def get_path_if_exists( episode_file )
+		episode_files = paths().collect{|p| create_episode_from_filename_series( p, episode_file.series_id, episode_file.series ) }
+		episode_files.select!{|ef| ef }
+		episode_files.each do | dn_ep | #download_episode_file
+		    if( 0 == ( episode_file <=> dn_ep ) )
+			return dn_ep.path
+		    end
+		end
+		return nil
+	    end
+
+	    def get_torrent_if_exists( episode_file )
+		torrents().each do | torrent |
+		    name = torrent['name']
+		    torrent_episode = create_episode_from_filename_series( name, episode_file.series_id, episode_file.series )
+		    if( torrent_episode )
+			if( 0 == ( episode_file <=> torrent_episode ) )
+			    return torrent
+			end
+		    end
+		end
+		return nil
+	    end
+
+	end
+
+	def self.format_title( title )
+	    #strip non alphanumeric characters and extra whitespace
+	    rval = title.gsub(/[^0-9a-z ]/i, '').gsub(/[ ]+/,' ').strip
+	    return rval
+	end
+
+	def self.path_contains_series?( path, title )
+	    formatted_title = P3::TV::format_title( title )
+	    if path.scan( /#{formatted_title}/i ).empty? #case insensative
+		if path.scan( /#{formatted_title.gsub(' ','.')}/i ).empty? # Titles.With.Periods.Instead.Of.Spaces
+		    return false
+		end
+	    end
+	    return true
+	end
+
+	class Search
+	    def initialize( settings = Settings.new )
+		@settings = settings
+		raise "tvdb api key required" unless @settings[:tvdb_api_key]
+		@tvdb = P3::Tvdb::Search.new( @settings[:tvdb_api_key] )
+		@eztv = {}
+	    end
+
+	    def find_series( title )
+		results = @tvdb.search( title )
+		results.select!{|r| r['FirstAired'] } #must have this field
+
+		#assume the more-recent show first
+		results.sort!{ | a,b |  b['FirstAired'] <=> a['FirstAired'] }
+		results = results.collect{|r| find_series_by_id( r['seriesid'] ) }
+		return results
+	    end
+
+	    def find_series_by_id( seriesid )
+		return @tvdb.get_series_by_id( seriesid )
+	    end
+
+	    def find_episodes_by_seriesid( seriesid )
+		series = find_series_by_id( seriesid )
+		if( series )
+		    series.episodes.each do | episode |
+			yield( episode ) if episode.season_number > 0
+		    end
+		end
+	    end
+
+	    def each_episode
+		@settings[:series].each do | series_hash |
+		    find_episodes_by_seriesid( series_hash[:id] ) do | episode |
+			yield( episode )
+		    end
+		end
+	    end
+
+	    def eztv( series_name )
+		unless( @eztv.has_key?( series_name ) )
+		    ez = P3::Eztv::Series.new( P3::TV::format_title( series_name ) )
+		    ez.high_def! if @settings[:high_def]
+		    @eztv[ series_name ] = ez
+		end
+		return @eztv[ series_name ]
+	    end
+
+	    def get_magnet_link_if_exists( episode_file )
+		ez = eztv( episode_file.series )
+		eztv_episode = ez.episode( episode_file.season, episode_file.episode )
+		return eztv_episode.magnet_link if eztv_episode
+		return nil
+	    end
+	end
+
+	def self.add_series!( title )
+	    settings = Settings.new
+	    search = Search.new( settings )
+
+	    results = search.find_series( title )
+
+	    settings.add_series!( results[0] )
+	    settings.save!
+	end
+
+	def self.test_mode_enabled?
+	    settings = Settings.new
+	    return ( settings[:verbose] and settings[:dry_run] )
+	end
+
+	def self.enable_test_mode!( enable )
+	    Settings::set!( :dry_run, enable )
+	    Settings::set!( :verbose, enable )
+	end
+
+
+	def self.catalog_file!( path, settings = Settings.new )
+	    downloads = Downloads.new( settings )
+	    return if settings.allowed_type?( path )
+	    library = Library.new( settings )
+	    episode = downloads.create_episode_from_filename( path )
+	    library.catalog!( episode ) if episode
+	    return nil
+	end
+
+	def self.catalog_downloads_series!( seriesid, settings = Settings.new )
+	    downloads = Downloads.new( settings )
+	    downloads.remove_completed_torrents!
+
+	    library = Library.new( settings )
+	    downloads.each_episode_file_in_series( seriesid ) do | episode_file |
+		library.catalog!( episode_file )
+	    end
+	    return nil
+	end
+
+	def self.catalog_downloads!( settings = Settings.new, downloads = Downloads.new( settings ) )
+	    library = Library.new( settings )
+	    downloads.each_episode_file do | episode_file |
+		library.catalog!( episode_file )
+	    end
+	    return nil
+	end
+
+	def self.download_missing_series!( seriesid, settings = Settings.new )
+	    search = Search.new( settings )
+	    library = Library.new( settings )
+	    downloads = Downloads.new( settings )
+
+	    settings.each_series_episode_file_status( seriesid, search, downloads, library ) do | episode_file |
+		downloads.download_episode_file!( episode_file )
+	    end
+	end
+
+	def self.download_missing!( settings = Settings.new )
+	    search = Search.new( settings )
+	    library = Library.new( settings )
+	    downloads = Downloads.new( settings )
+	    settings[:series].each do | series |
+		settings.each_series_episode_file_status( series[:id], search, downloads, library ) do | episode_file |
+		    downloads.download_episode_file!( episode_file )
+		end
+	    end
+	end
+
+
+    end
+end

data/p3-tv.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "p3-tv"
+  spec.version       = "0.9.1"
+  spec.authors       = ["Poul Hornsleth"]
+  spec.email         = ["poulh@umich.edu"]
+  spec.summary       = "TV Show Organizer, Renamer, and Downloader"
+  spec.description   = "Organize and rename your TV Shows. Automatically find links to missing shows. Includes Command-Line Utility 'p3tv'"
+  spec.homepage      = "https://github.com/poulh/p3-tv"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+
+
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "p3-eztv", "~> 0.0.7"
+  spec.add_runtime_dependency "p3-tvdb", "~> 0.9.0"
+  spec.add_runtime_dependency "p3-transmission", "~> 0.0.15"
+  spec.add_runtime_dependency "highline", "~> 1.7"
+
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: p3-tv
+version: !ruby/object:Gem::Version
+  version: 0.9.1
+platform: ruby
+authors:
+- Poul Hornsleth
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: p3-eztv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+- !ruby/object:Gem::Dependency
+  name: p3-tvdb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: p3-transmission
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.15
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.15
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+description: Organize and rename your TV Shows. Automatically find links to missing
+  shows. Includes Command-Line Utility 'p3tv'
+email:
+- poulh@umich.edu
+executables:
+- p3tv
+- p3tv_json_api
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- bin/p3tv
+- bin/p3tv_json_api
+- lib/p3-tv.rb
+- p3-tv.gemspec
+homepage: https://github.com/poulh/p3-tv
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14.1
+signing_key: 
+specification_version: 4
+summary: TV Show Organizer, Renamer, and Downloader
+test_files: []