/// <summary>
/// Sets the default values specific to the <see cref="NfoMovieMetadataExtractor"/>
/// </summary>
public NfoMovieMetadataExtractorSettings()
{
MovieNfoFileNames = new HashSet <string> {
"movie"
};
ImdbIdRegex = new SerializableRegex(REGEX_STRING_IMDBID);
}
public async Task TestSerialization()
{
var context = BuildXLContext.CreateInstanceForTesting();
var pathTable = context.PathTable;
var symbolTable = new SymbolTable(pathTable.StringTable);
var whitelist = new FileAccessWhitelist(context);
var path1 = AbsolutePath.Create(pathTable, @"\\fakePath\foo.txt");
var path2 = AbsolutePath.Create(pathTable, @"\\fakePath\bar.txt");
var regex1 = new SerializableRegex(@"dir\foo.txt");
var executableEntry1 = new ExecutablePathWhitelistEntry(
path1, regex1, true, "entry1");
var executableEntry2 = new ExecutablePathWhitelistEntry(
path2, new SerializableRegex("bar"), false, "entry2");
whitelist.Add(executableEntry1);
whitelist.Add(executableEntry2);
var symbol1 = FullSymbol.Create(symbolTable, "symbol1");
var valueEntry = new ValuePathFileAccessWhitelistEntry(
symbol1, new SerializableRegex("symbol1"), false, null);
var symbol2 = FullSymbol.Create(symbolTable, "symbol2");
var valueEntry2 = new ValuePathFileAccessWhitelistEntry(
symbol2, new SerializableRegex("symbol2"), false, "entry4");
whitelist.Add(valueEntry);
whitelist.Add(valueEntry2);
XAssert.AreEqual(3, whitelist.UncacheableEntryCount);
XAssert.AreEqual(1, whitelist.CacheableEntryCount);
XAssert.AreEqual("Unnamed", valueEntry.Name);
using (var ms = new MemoryStream())
{
BuildXLWriter writer = new BuildXLWriter(true, ms, true, true);
whitelist.Serialize(writer);
ms.Position = 0;
BuildXLReader reader = new BuildXLReader(true, ms, true);
var deserialized = await FileAccessWhitelist.DeserializeAsync(reader, Task.FromResult <PipExecutionContext>(context));
XAssert.AreEqual(2, deserialized.ExecutablePathEntries.Count);
XAssert.AreEqual(1, deserialized.ExecutablePathEntries[path1].Count);
XAssert.AreEqual(true, deserialized.ExecutablePathEntries[path1][0].AllowsCaching);
XAssert.AreEqual(regex1.ToString(), deserialized.ExecutablePathEntries[path1][0].PathRegex.ToString());
XAssert.AreEqual(executableEntry1.Name, deserialized.ExecutablePathEntries[path1][0].Name);
XAssert.AreEqual(executableEntry2.Name, deserialized.ExecutablePathEntries[path2][0].Name);
XAssert.AreEqual(2, deserialized.ValuePathEntries.Count);
XAssert.AreEqual(1, deserialized.ValuePathEntries[symbol1].Count);
XAssert.AreEqual(false, deserialized.ValuePathEntries[symbol1][0].AllowsCaching);
XAssert.AreEqual(valueEntry.Name, deserialized.ValuePathEntries[symbol1][0].Name);
XAssert.AreEqual(valueEntry2.Name, deserialized.ValuePathEntries[symbol2][0].Name);
XAssert.AreEqual(3, deserialized.UncacheableEntryCount);
XAssert.AreEqual(1, deserialized.CacheableEntryCount);
}
}
public MovieMetadataExtractorSettings()
{
// Init default patterns.
MovieYearPatterns = new SerializableRegex[]
{
new SerializableRegex(@"(?<title>[^\\|\/]+?)\s*[\[\(]?(?<year>(19|20)\d{2})[\]\)]?[\.|\\|\/]*", RegexOptions.IgnoreCase),
};
}
/// <summary>
/// Sets the default values specific to the <see cref="NfoMovieMetadataExtractor"/>
/// </summary>
public NfoMovieMetadataExtractorSettings()
{
MovieNfoFileNames = new HashSet <string> {
"movie"
};
ImdbIdRegex = new SerializableRegex(REGEX_STRING_IMDBID);
PreferredCertificationCountry = ""; //Use first available
}
public VideoMetadataExtractorSettings()
{
VideoFileExtensions = new List <string>(DEFAULT_VIDEO_FILE_EXTENSIONS);
SubtitleFileExtensions = new List <string>(DEFAULT_SUBTITLE_FILE_EXTENSIONS);
SubtitleFolders = new List <string>(DEFAULT_SUBTITLE_FOLDERS);
MultiPartVideoRegex = new SerializableRegex(@"\\(?<file>[^\\|^\/]*)(\s|-|_)*(?<media>Disc|CD|DVD)\s*(?<disc>\d{1,2})", RegexOptions.IgnoreCase);
StereoVideoRegex = new SerializableRegex(@"\\.*?[-. _](3d|.*?)?([-. _]?|3d)(?<mode>h[-]?|half[-]?|full[-]?)*(?<stereo>sbs|tab|ou|mvc|anaglyph)[-. _]", RegexOptions.IgnoreCase);
MaxSampleSize = 150;
SampleVideoRegex = new SerializableRegex(@"(sample)|(trailer)", RegexOptions.IgnoreCase);
}
public VideoMetadataExtractorSettings()
{
_videoFileExtensions = DEFAULT_VIDEO_FILE_EXTENSIONS;
MultiPartVideoRegex = new SerializableRegex(@"\\(?<file>[^\\|^\/]*)(\s|-|_)*(?<media>Disc|Disk|CD|DVD|File)\s*(?<disc>\d{1,2})", RegexOptions.IgnoreCase);
StereoVideoRegex = new SerializableRegex(@"\\.*?[-. _](3d|.*?)?([-. _]?|3d)(?<mode>h[-]?|half[-]?|full[-]?)*(?<stereo>sbs|tab|ou|mvc|anaglyph)[-. _]", RegexOptions.IgnoreCase);
MaxSampleSize = 150;
SampleVideoRegex = new SerializableRegex(@"(sample)|(trailer)", RegexOptions.IgnoreCase);
CacheOfflineFanArt = true;
CacheLocalFanArt = false;
CacheOfflineMovieFanArt = true;
CacheLocalMovieFanArt = false;
CacheOfflineSeriesFanArt = true;
CacheLocalSeriesFanArt = false;
}
/// <summary>
/// Sets the default values specific to the <see cref="NfoMovieMetadataExtractor"/>
/// </summary>
public NfoMovieMetadataExtractorSettings()
{
MovieNfoFileNames = new HashSet<string> { "movie" };
ImdbIdRegex = new SerializableRegex(REGEX_STRING_IMDBID);
}
public async Task TestSerialization()
{
var context = BuildXLContext.CreateInstanceForTesting();
var pathTable = context.PathTable;
var stringTable = context.StringTable;
var symbolTable = new SymbolTable(pathTable.StringTable);
var allowlist = new FileAccessAllowlist(context);
//Allowlist with full paths
var path1 = new DiscriminatingUnion <AbsolutePath, PathAtom>(AbsolutePath.Create(pathTable, @"\\fakePath\foo.txt"));
var path2 = new DiscriminatingUnion <AbsolutePath, PathAtom>(AbsolutePath.Create(pathTable, @"\\fakePath\bar.txt"));
var regex1 = new SerializableRegex(@"dir\foo.txt");
var executableEntry1 = new ExecutablePathAllowlistEntry(
path1, regex1, true, "entry1");
var executableEntry2 = new ExecutablePathAllowlistEntry(
path2, new SerializableRegex("bar"), false, "entry2");
allowlist.Add(executableEntry1);
allowlist.Add(executableEntry2);
// Allowlist with executable names only
var path3 = new DiscriminatingUnion <AbsolutePath, PathAtom>(PathAtom.Create(stringTable, "alice.txt"));
var path4 = new DiscriminatingUnion <AbsolutePath, PathAtom>(PathAtom.Create(stringTable, "bob.txt"));
var regex3 = new SerializableRegex(@"dir\alice.txt");
var executableEntry3 = new ExecutablePathAllowlistEntry(
path3, regex3, true, "entry5");
var executableEntry4 = new ExecutablePathAllowlistEntry(
path4, new SerializableRegex("bob"), false, "entry6");
allowlist.Add(executableEntry3);
allowlist.Add(executableEntry4);
var symbol1 = FullSymbol.Create(symbolTable, "symbol1");
var valueEntry = new ValuePathFileAccessAllowlistEntry(
symbol1, new SerializableRegex("symbol1"), false, null);
var symbol2 = FullSymbol.Create(symbolTable, "symbol2");
var valueEntry2 = new ValuePathFileAccessAllowlistEntry(
symbol2, new SerializableRegex("symbol2"), false, "entry4");
allowlist.Add(valueEntry);
allowlist.Add(valueEntry2);
XAssert.AreEqual(4, allowlist.UncacheableEntryCount);
XAssert.AreEqual(2, allowlist.CacheableEntryCount);
XAssert.AreEqual("Unnamed", valueEntry.Name);
using (var ms = new MemoryStream())
{
BuildXLWriter writer = new BuildXLWriter(true, ms, true, true);
allowlist.Serialize(writer);
ms.Position = 0;
BuildXLReader reader = new BuildXLReader(true, ms, true);
var deserialized = await FileAccessAllowlist.DeserializeAsync(reader, Task.FromResult <PipExecutionContext>(context));
var path1Absolute = (AbsolutePath)path1.GetValue();
var path2Absolute = (AbsolutePath)path2.GetValue();
var path3Atom = ((PathAtom)path3.GetValue()).StringId;
var path4Atom = ((PathAtom)path4.GetValue()).StringId;
XAssert.AreEqual(2, deserialized.ExecutablePathEntries.Count);
XAssert.AreEqual(1, deserialized.ExecutablePathEntries[path1Absolute].Count);
XAssert.AreEqual(true, deserialized.ExecutablePathEntries[path1Absolute][0].AllowsCaching);
XAssert.AreEqual(regex1.ToString(), deserialized.ExecutablePathEntries[path1Absolute][0].PathRegex.ToString());
XAssert.AreEqual(executableEntry1.Name, deserialized.ExecutablePathEntries[path1Absolute][0].Name);
XAssert.AreEqual(executableEntry2.Name, deserialized.ExecutablePathEntries[path2Absolute][0].Name);
XAssert.AreEqual(2, deserialized.ToolExecutableNameEntries.Count);
XAssert.AreEqual(1, deserialized.ToolExecutableNameEntries[path3Atom].Count);
XAssert.AreEqual(true, deserialized.ToolExecutableNameEntries[path3Atom][0].AllowsCaching);
XAssert.AreEqual(regex3.ToString(), deserialized.ToolExecutableNameEntries[path3Atom][0].PathRegex.ToString());
XAssert.AreEqual(executableEntry3.Name, deserialized.ToolExecutableNameEntries[path3Atom][0].Name);
XAssert.AreEqual(executableEntry4.Name, deserialized.ToolExecutableNameEntries[path4Atom][0].Name);
XAssert.AreEqual(2, deserialized.ValuePathEntries.Count);
XAssert.AreEqual(1, deserialized.ValuePathEntries[symbol1].Count);
XAssert.AreEqual(false, deserialized.ValuePathEntries[symbol1][0].AllowsCaching);
XAssert.AreEqual(valueEntry.Name, deserialized.ValuePathEntries[symbol1][0].Name);
XAssert.AreEqual(valueEntry2.Name, deserialized.ValuePathEntries[symbol2][0].Name);
XAssert.AreEqual(4, deserialized.UncacheableEntryCount);
XAssert.AreEqual(2, deserialized.CacheableEntryCount);
}
}
public SeriesMetadataExtractorSettings()
{
// Init default replacements
Replacements = new Replacement[]
{
new Replacement {
Enabled = true, BeforeMatch = true, Pattern = "720p", ReplaceBy = "", IsRegex = false
},
new Replacement {
Enabled = true, BeforeMatch = true, Pattern = "1080i", ReplaceBy = "", IsRegex = false
},
new Replacement {
Enabled = true, BeforeMatch = true, Pattern = "1080p", ReplaceBy = "", IsRegex = false
},
new Replacement {
Enabled = true, BeforeMatch = true, Pattern = "x264", ReplaceBy = "", IsRegex = false
},
new Replacement {
Enabled = true, BeforeMatch = true, Pattern = @"(?<!(?:S\d+.?E\\d+\-E\d+.*|S\d+.?E\d+.*|\s\d+x\d+.*))P[ar]*t[\s|\.|\-|_]?(\d+)(\s?of\s\d{1,2})?", ReplaceBy = "S01E${1}", IsRegex = true
},
};
// Init default patterns.
SeriesPatterns = new MatchPattern[]
{
// Multi-episodes pattern
// "Series S1E01-E02 - Episodes"
new MatchPattern {
Enabled = true, Pattern = @"(?<series>[^\\]+)\WS(?<seasonnum>\d+)[\s|\.|\-|_]{0,1}E((?<episodenum>\d+)[\-_]?)+E(?<endepisodenum>\d+)+ - (?<episode>.*)\.", RegexOptions = RegexOptions.IgnoreCase
},
// "Series.Name.S01E01-E02.Episode.Or.Release.Info"
new MatchPattern {
Enabled = true, Pattern = @"(?<series>[^\\]+).S(?<seasonnum>\d+)[\s|\.|\-|_]{0,1}E((?<episodenum>\d+)[\-|_]?)+E(?<endepisodenum>\d+)+(?<episode>.*)\.", RegexOptions = RegexOptions.IgnoreCase
},
// Series\Season...\S01E01-E02* or Series\Season...\1x01-02*
new MatchPattern {
Enabled = true, Pattern = @"(?<series>[^\\]*)\\[^\\]*(?<seasonnum>\d+)[^\\]*\\S*(?<seasonnum>\d+)[EX]((?<episodenum>\d+)[\-|_]?)+[EX](?<endepisodenum>\d+)*(?<episode>.*)\.", RegexOptions = RegexOptions.IgnoreCase
},
// Series\Season...\S01E01* or Series\Season...\1x01*
new MatchPattern {
Enabled = true, Pattern = @"(?<series>[^\\]*)\\[^\\]*(?<seasonnum>\d+)[^\\]*\\S*(?<seasonnum>\d+)[EX](?<episodenum>\d+)*(?<episode>.*)\.", RegexOptions = RegexOptions.IgnoreCase
},
// MP1 EpisodeScanner recommendations for recordings: Series - (Episode) S1E1, also "S1 E1", "S1-E1", "S1.E1", "S1_E1"
new MatchPattern {
Enabled = true, Pattern = @"(?<series>[^\\]+) - \((?<episode>.*)\) S(?<seasonnum>[0-9]+?)[\s|\.|\-|_]{0,1}E(?<episodenum>[0-9]+?)", RegexOptions = RegexOptions.IgnoreCase
},
// "Series 1x1 - Episode" and multi-episodes "Series 1x1_2 - Episodes"
new MatchPattern {
Enabled = true, Pattern = @"(?<series>[^\\]+)\W(?<seasonnum>\d+)x((?<episodenum>\d+)_?)+ - (?<episode>.*)\.", RegexOptions = RegexOptions.IgnoreCase
},
// "Series S1E01 - Episode" and multi-episodes "Series S1E01_02 - Episodes", also "S1 E1", "S1-E1", "S1.E1", "S1_E1"
new MatchPattern {
Enabled = true, Pattern = @"(?<series>[^\\]+)\WS(?<seasonnum>\d+)[\s|\.|\-|_]{0,1}E((?<episodenum>\d+)_?)+ - (?<episode>.*)\.", RegexOptions = RegexOptions.IgnoreCase
},
// "Series.Name.1x01.Episode.Or.Release.Info"
new MatchPattern {
Enabled = true, Pattern = @"(?<series>[^\\]+).(?<seasonnum>\d+)x((?<episodenum>\d+)_?)+(?<episode>.*)\.", RegexOptions = RegexOptions.IgnoreCase
},
// "Series.Name.S01E01.Episode.Or.Release.Info", also "S1 E1", "S1-E1", "S1.E1", "S1_E1"
new MatchPattern {
Enabled = true, Pattern = @"(?<series>[^\\]+).S(?<seasonnum>\d+)[\s|\.|\-|_]{0,1}E((?<episodenum>\d+)_?)+(?<episode>.*)\.", RegexOptions = RegexOptions.IgnoreCase
},
// Folder + filename pattern
// "Series\1\11 - Episode" "Series\Staffel 2\11 - Episode" "Series\Season 3\12 Episode" "Series\3. Season\13-Episode"
new MatchPattern {
Enabled = true, Pattern = @"(?<series>[^\\]*)\\[^\\|\d]*(?<seasonnum>\d+)\D*\\(?<episodenum>\d+)\s*-\s*(?<episode>[^\\]+)\.", RegexOptions = RegexOptions.IgnoreCase
},
// "Series.Name.101.Episode.Or.Release.Info", attention: this expression can lead to false matches for every filename with nnn included
new MatchPattern {
Enabled = true, Pattern = @"(?<series>[^\\]+)\D(?<seasonnum>\d{1})(?<episodenum>\d{2})\D(?<episode>.*)\.", RegexOptions = RegexOptions.IgnoreCase
},
};
SeriesYearPattern = new SerializableRegex(@"(?<series>.*)[( .-_]+(?<year>\d{4})", RegexOptions.IgnoreCase);
}
public GenreMapping(int genreId, SerializableRegex genrePattern)
{
GenreId = genreId;
GenrePattern = genrePattern;
}
public GenreMapping()
{
GenreId = 0;
GenrePattern = null;
}
