public void IsUpgradeTestLanguage(Quality current, int currentVersion, Language currentLanguage, Quality newQuality, int newVersion, Language newLanguage, Quality cutoff, Language languageCutoff, bool expected)
{
GivenAutoDownloadPropers(ProperDownloadTypes.PreferAndUpgrade);
var profile = new QualityProfile
{
UpgradeAllowed = true,
Items = Qualities.QualityFixture.GetDefaultQualities(),
Cutoff = cutoff.Id,
};
var langProfile = new LanguageProfile
{
UpgradeAllowed = true,
Languages = LanguageFixture.GetDefaultLanguages(),
Cutoff = languageCutoff
};
Subject.IsUpgradable(
profile,
langProfile,
new QualityModel(current, new Revision(version: currentVersion)),
currentLanguage,
NoPreferredWordScore,
new QualityModel(newQuality, new Revision(version: newVersion)),
newLanguage,
NoPreferredWordScore)
.Should().Be(expected);
}
public SourceStats GetProfileStats(LanguageProfile profile)
{
SourceStats stats;
_profileStats.TryGetValue(profile, out stats);
return(stats);
}
internal static LanguageProfile InternalGetCurrentLanguageProfile(string name, out Type winUserLanguageType)
{
RunspaceConfiguration psConfig = RunspaceConfiguration.Create();
var psRunspace = RunspaceFactory.CreateRunspace(psConfig);
psRunspace.Open();
List <string> languageTags = new List <string>();
using (Pipeline psPipeline = psRunspace.CreatePipeline())
{
Command command = new Command("Get-WinUserLanguageList");
psPipeline.Commands.Add(command);
var results = psPipeline.Invoke();
dynamic member = results.First().BaseObject;
winUserLanguageType = member[0].GetType();
foreach (var mem in member)
{
languageTags.Add(mem.LanguageTag);
}
}
var languageProfile = new LanguageProfile()
{
LanguageTags = languageTags, Name = name
};
return(languageProfile);
}
public void should_return_false_if_proper_and_autoDownloadPropers_is_do_not_prefer()
{
GivenAutoDownloadPropers(ProperDownloadTypes.DoNotPrefer);
var profile = new QualityProfile
{
Items = Qualities.QualityFixture.GetDefaultQualities(),
};
var langProfile = new LanguageProfile
{
Languages = LanguageFixture.GetDefaultLanguages(),
Cutoff = Language.English
};
Subject.IsUpgradable(
profile,
langProfile,
new QualityModel(Quality.DVD, new Revision(version: 1)),
Language.English,
NoPreferredWordScore,
new QualityModel(Quality.DVD, new Revision(version: 2)),
Language.English,
NoPreferredWordScore)
.Should().BeFalse();
}
public bool IsUpgradeAllowed(QualityProfile qualityProfile, LanguageProfile languageProfile, QualityModel currentQuality, Language currentLanguage, QualityModel newQuality, Language newLanguage)
{
var isQualityUpgrade = new QualityModelComparer(qualityProfile).Compare(newQuality, currentQuality) > 0;
var isLanguageUpgrade = new LanguageComparer(languageProfile).Compare(newLanguage, currentLanguage) > 0;
if (isQualityUpgrade && qualityProfile.UpgradeAllowed ||
isLanguageUpgrade && languageProfile.UpgradeAllowed)
{
_logger.Debug("At least one profile allows upgrading");
return(true);
}
if (isQualityUpgrade && !qualityProfile.UpgradeAllowed)
{
_logger.Debug("Quality profile does not allow upgrades, skipping");
return(false);
}
if (isLanguageUpgrade && !languageProfile.UpgradeAllowed)
{
_logger.Debug("Language profile does not allow upgrades, skipping");
return(false);
}
return(true);
}
public void should_lazyload_quality_profile()
{
var profile = new QualityProfile
{
Items = Qualities.QualityFixture.GetDefaultQualities(Quality.Bluray1080p, Quality.DVD, Quality.HDTV720p),
Cutoff = Quality.Bluray1080p.Id,
Name = "TestProfile"
};
var langProfile = new LanguageProfile
{
Name = "TestProfile",
Languages = Languages.LanguageFixture.GetDefaultLanguages(Language.English),
Cutoff = Language.English
};
Mocker.Resolve <QualityProfileRepository>().Insert(profile);
Mocker.Resolve <LanguageProfileRepository>().Insert(langProfile);
var series = Builder <Series> .CreateNew().BuildNew();
series.QualityProfileId = profile.Id;
series.LanguageProfileId = langProfile.Id;
Subject.Insert(series);
StoredModel.QualityProfile.Should().NotBeNull();
StoredModel.LanguageProfile.Should().NotBeNull();
}
private void PopulateFields(LanguageProfile profile)
{
if (profile != null)
{
txtName.Text = profile.Name;
txtExtensions.Lines = profile.Extensions;
var commentBuilder = new StringBuilder();
foreach (var indicator in profile.CommentIndicators.ToList().FindAll(x => !x.Multiline))
{
commentBuilder.AppendLine(indicator.StartIndicator);
}
txtSingleComments.Text = commentBuilder.ToString();
//todo allow multiple multiline comment rules
var multilineIndicators = profile.CommentIndicators.ToList().FindAll(x => x.Multiline);
txtmultistart.Text = multilineIndicators.Count > 0 ? multilineIndicators[0].StartIndicator : "";
txtmultiend.Text = multilineIndicators.Count > 0 && multilineIndicators[0].HasEndIndicator ? multilineIndicators[0].EndIndicator : "";
txtPreprocessors.Lines = profile.Preprocessors;
chkInlineComments.Checked = profile.AllowInlineComments;
chkInterspersedComments.Checked = profile.AllowInterspersedComments;
}
else
{
txtName.Text = txtExtensions.Text = txtSingleComments.Text = txtmultistart.Text = txtmultiend.Text = "";
}
}
public void should_return_true_if_cutoffs_are_met_but_is_a_revision_upgrade()
{
QualityProfile _profile = new QualityProfile
{
Cutoff = Quality.HDTV1080p.Id,
Items = Qualities.QualityFixture.GetDefaultQualities(),
UpgradeAllowed = true
};
LanguageProfile _langProfile = new LanguageProfile
{
Cutoff = Language.English,
Languages = LanguageFixture.GetDefaultLanguages(),
UpgradeAllowed = true
};
Subject.CutoffNotMet(
_profile,
_langProfile,
new QualityModel(Quality.WEBDL1080p, new Revision(version: 1)),
Language.English,
NoPreferredWordScore,
new QualityModel(Quality.WEBDL1080p, new Revision(version: 2)),
NoPreferredWordScore).Should().BeTrue();
}
public void should_return_false_if_quality_profile_does_not_allow_upgrades_but_cutoff_is_set_to_highest_quality_and_language_cutoff_is_met()
{
QualityProfile _profile = new QualityProfile
{
Cutoff = Quality.WEBDL1080p.Id,
Items = Qualities.QualityFixture.GetDefaultQualities(),
UpgradeAllowed = false
};
LanguageProfile _langProfile = new LanguageProfile
{
Cutoff = Language.English,
Languages = LanguageFixture.GetDefaultLanguages(Language.Spanish, Language.English, Language.Arabic),
UpgradeAllowed = true
};
Subject.CutoffNotMet(
_profile,
_langProfile,
new QualityModel(Quality.WEBDL1080p),
Language.English,
NoPreferredWordScore,
new QualityModel(Quality.Bluray1080p),
NoPreferredWordScore).Should().BeFalse();
}
public bool IsUpgradable(QualityProfile qualityProfile, LanguageProfile languageProfile, QualityModel currentQuality, Language currentLanguage, int currentScore, QualityModel newQuality, Language newLanguage, int newScore)
{
var qualityComparer = new QualityModelComparer(qualityProfile);
var qualityCompare = qualityComparer.Compare(newQuality?.Quality, currentQuality.Quality);
var downloadPropersAndRepacks = _configService.DownloadPropersAndRepacks;
if (qualityCompare > 0)
{
_logger.Debug("New item has a better quality");
return(true);
}
if (qualityCompare < 0)
{
_logger.Debug("Existing item has better quality, skipping");
return(false);
}
var qualityRevisionComapre = newQuality?.Revision.CompareTo(currentQuality.Revision);
// Accept unless the user doesn't want to prefer propers, optionally they can
// use preferred words to prefer propers/repacks over non-propers/repacks.
if (downloadPropersAndRepacks != ProperDownloadTypes.DoNotPrefer &&
qualityRevisionComapre > 0)
{
_logger.Debug("New item has a better quality revision");
return(true);
}
// Reject unless the user does not prefer propers/repacks and it's a revision downgrade.
if (downloadPropersAndRepacks != ProperDownloadTypes.DoNotPrefer &&
qualityRevisionComapre < 0)
{
_logger.Debug("Existing item has a better quality revision, skipping");
return(false);
}
var languageCompare = new LanguageComparer(languageProfile).Compare(newLanguage, currentLanguage);
if (languageCompare > 0)
{
_logger.Debug("New item has a more preferred language");
return(true);
}
if (languageCompare < 0)
{
_logger.Debug("Existing item has better language, skipping");
return(false);
}
if (!IsPreferredWordUpgradable(currentScore, newScore))
{
_logger.Debug("Existing item has an equal or better preferred word score, skipping");
return(false);
}
_logger.Debug("New item has a better preferred word score");
return(true);
}
public void should_return_true_if_cutoffs_are_met_and_score_is_higher()
{
QualityProfile _profile = new QualityProfile
{
Cutoff = Quality.HDTV720p.Id,
Items = Qualities.QualityFixture.GetDefaultQualities(),
UpgradeAllowed = true
};
LanguageProfile _langProfile = new LanguageProfile
{
Cutoff = Language.Spanish,
Languages = LanguageFixture.GetDefaultLanguages(),
UpgradeAllowed = true
};
Subject.CutoffNotMet(
_profile,
_langProfile,
new QualityModel(Quality.HDTV720p, new Revision(version: 2)),
Language.Spanish,
NoPreferredWordScore,
new QualityModel(Quality.Bluray1080p, new Revision(version: 2)),
10).Should().BeTrue();
}
public static void SetProfile(LanguageProfile profile)
{
RunspaceConfiguration psConfig = RunspaceConfiguration.Create();
var psRunspace = RunspaceFactory.CreateRunspace(psConfig);
psRunspace.Open();
using (Pipeline psPipeline = psRunspace.CreatePipeline())
{
Command command = new Command("Set-WinUserLanguageList");
var langType = Type.GetType(AppConfig.CurrentConfig.InternalAppConfig.WinUserLanguageType);
IList langList = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(langType));
foreach (var tag in profile.LanguageTags)
{
var lang = Activator.CreateInstance(langType, tag);
langList.Add(lang);
}
psPipeline.Commands.Add(command);
command.Parameters.Add("LanguageList", langList);
command.Parameters.Add("Force", true);
psPipeline.Invoke();
}
}
public LanguageComparer(LanguageProfile profile)
{
Ensure.That(profile, () => profile).IsNotNull();
Ensure.That(profile.Languages, () => profile.Languages).HasItems();
_profile = profile;
}
public void AddProfile(LanguageProfile profile)
{
if (InternalAppConfig.LanguageProfiles.Any(p => p.Name == profile.Name))
{
throw new Exception("Profile with given name already exists");
}
InternalAppConfig.LanguageProfiles.Add(profile);
SaveConfig();
}
public void Select(LanguageProfile profile)
{
var index = _profiles.IndexOf(profile);
if (index > -1)
{
Select(index);
}
}
public bool LanguageCutoffNotMet(LanguageProfile languageProfile, Language currentLanguage)
{
var cutoff = languageProfile.UpgradeAllowed
? languageProfile.Cutoff
: languageProfile.FirstAllowedLanguage();
var languageCompare = new LanguageComparer(languageProfile).Compare(currentLanguage, cutoff);
return(languageCompare < 0);
}
public void CreateLangProfileContextMenuItem(LanguageProfile profile)
{
var item = new ContextMenuItem()
{
ItemCommand = SetProfileCommand(profile),
Name = profile.Name
};
ProfileItems.Add(item);
}
public void Setup()
{
_profile = Builder <QualityProfile> .CreateNew()
.Build();
_langProfile = Builder <LanguageProfile> .CreateNew()
.Build();
_delayProfile = Builder <DelayProfile> .CreateNew()
.With(d => d.PreferredProtocol = DownloadProtocol.Usenet)
.Build();
var series = Builder <Series> .CreateNew()
.With(s => s.QualityProfile = _profile)
.With(s => s.LanguageProfile = _langProfile)
.Build();
_remoteEpisode = Builder <RemoteEpisode> .CreateNew()
.With(r => r.Series = series)
.Build();
_profile.Items = new List <QualityProfileQualityItem>();
_profile.Items.Add(new QualityProfileQualityItem {
Allowed = true, Quality = Quality.HDTV720p
});
_profile.Items.Add(new QualityProfileQualityItem {
Allowed = true, Quality = Quality.WEBDL720p
});
_profile.Items.Add(new QualityProfileQualityItem {
Allowed = true, Quality = Quality.Bluray720p
});
_profile.Cutoff = Quality.WEBDL720p.Id;
_langProfile.Cutoff = Language.Spanish;
_langProfile.Languages = Languages.LanguageFixture.GetDefaultLanguages();
_remoteEpisode.ParsedEpisodeInfo = new ParsedEpisodeInfo();
_remoteEpisode.Release = new ReleaseInfo();
_remoteEpisode.Release.DownloadProtocol = DownloadProtocol.Usenet;
_remoteEpisode.Episodes = Builder <Episode> .CreateListOfSize(1).Build().ToList();
_remoteEpisode.Episodes.First().EpisodeFileId = 0;
Mocker.GetMock <IDelayProfileService>()
.Setup(s => s.BestForTags(It.IsAny <HashSet <int> >()))
.Returns(_delayProfile);
Mocker.GetMock <IPendingReleaseService>()
.Setup(s => s.GetPendingRemoteEpisodes(It.IsAny <int>()))
.Returns(new List <RemoteEpisode>());
}
private static ICommand SetProfileCommand(LanguageProfile languageProfile)
{
return(new BasicCommand(() =>
{
var task = new Task(() =>
{
LanguageProfileSetter.SetProfile(languageProfile);
});
task.Start();
}
));
}
public void Remove(LanguageProfile profile)
{
var index = _profiles.IndexOf(profile);
if (index > -1)
{
profilesList.Items.RemoveAt(index);
profilesList.SelectedIndex = index > 0 ? index - 1 : 0;
_profiles.Remove(profile);
PopulateInternal(true);
}
}
static RssFeedComponent()
{
Assembly assembly = Assembly.GetExecutingAssembly();
foreach (string resName in assembly.GetManifestResourceNames())
{
if (resName.EndsWith(".ldp"))
{
BinarySerializer ser = new BinarySerializer(assembly.GetManifestResourceStream(resName));
LanguageProfile langProfile = new LanguageProfile(ser);
ser.Close();
mCodePageDetector.AddLanguageProfile(langProfile);
}
}
}
public static LanguageProfileResource ToResource(this LanguageProfile model)
{
if (model == null)
{
return(null);
}
return(new LanguageProfileResource
{
Id = model.Id,
Name = model.Name,
UpgradeAllowed = model.UpgradeAllowed,
Cutoff = model.Cutoff,
Languages = model.Languages.ConvertAll(ToResource)
});
}
public void Setup()
{
var profile = new QualityProfile
{
Name = "Test",
Cutoff = Quality.WEBDL720p.Id,
Items = Qualities.QualityFixture.GetDefaultQualities(),
};
var languageProfile = new LanguageProfile
{
Name = "Test",
Languages = LanguageFixture.GetDefaultLanguages(Language.English),
Cutoff = Language.English
};
profile = Db.Insert(profile);
languageProfile = Db.Insert(languageProfile);
var series = Builder <Series> .CreateListOfSize(1)
.All()
.With(v => v.QualityProfileId = profile.Id)
.With(v => v.LanguageProfileId = languageProfile.Id)
.BuildListOfNew();
Db.InsertMany(series);
var episodeFiles = Builder <EpisodeFile> .CreateListOfSize(1)
.All()
.With(v => v.SeriesId = series[0].Id)
.With(v => v.Quality = new QualityModel())
.BuildListOfNew();
Db.InsertMany(episodeFiles);
var episodes = Builder <Episode> .CreateListOfSize(10)
.All()
.With(v => v.Monitored = true)
.With(v => v.EpisodeFileId = episodeFiles[0].Id)
.With(v => v.SeriesId = series[0].Id)
.BuildListOfNew();
Db.InsertMany(episodes);
}
//-------------------------------------------------------------------------
/// <summary>
/// Check if the user has selected a language preference.
/// </summary>
private void LanguageInit()
{
if (PlayerPrefs.HasKey("Language"))
{
Debug.Log("Found previous saved language: " +
PlayerPrefs.GetString("Language"));
LanguageProfile languageProfile =
Array.Find(languageProfiles,
l => l.language.ToString() ==
PlayerPrefs.GetString("Language"));
LoadLocalizedText(languageProfile.language);
}
else
{
LoadLocalizedText(Application.systemLanguage);
}
}
//-------------------------------------------------------------------------
#endregion
#region Localizing Management
//--------------------------------------------------------------------------
/// <summary>
/// Check if the system contains the language profile and load data.
/// </summary>
/// <param name="language"></param>
public void LoadLocalizedText(SystemLanguage language =
SystemLanguage.Unknown)
{
if (language == SystemLanguage.Unknown)
{
return;
}
LanguageProfile profile = Array.Find(languageProfiles,
x => x.language.Equals(language));
if (profile != null)
{
LoadLocalizedData(profile.textFile);
}
else
{
Debug.LogErrorFormat("Language profile not found: " +
"{0}", language);
}
}
public void Setup()
{
_profile = new QualityProfile
{
Cutoff = Quality.WEBDL720p.Id,
Items = QualityFixture.GetDefaultQualities(),
};
_profileCustom = new QualityProfile
{
Cutoff = Quality.WEBDL720p.Id,
Items = QualityFixture.GetDefaultQualities(Quality.DVD),
};
_languageProfile = new LanguageProfile
{
Cutoff = Language.Spanish,
Languages = Languages.LanguageFixture.GetDefaultLanguages()
};
}
public void should_return_true_if_cutoff_is_not_met_and_language_is_higher()
{
QualityProfile _profile = new QualityProfile
{
Cutoff = Quality.HDTV720p.Id,
Items = Qualities.QualityFixture.GetDefaultQualities(),
};
LanguageProfile _langProfile = new LanguageProfile
{
Cutoff = Language.Spanish,
Languages = LanguageFixture.GetDefaultLanguages()
};
Subject.CutoffNotMet(
_profile,
_langProfile,
new QualityModel(Quality.SDTV, new Revision(version: 2)),
Language.French,
NoPreferredWordScore).Should().BeTrue();
}
public bool CutoffNotMet(QualityProfile profile, LanguageProfile languageProfile, QualityModel currentQuality, Language currentLanguage, int currentScore, QualityModel newQuality = null, int newScore = 0)
{
// If we can upgrade the language (it is not the cutoff) then the quality doesn't
// matter as we can always get same quality with prefered language.
if (LanguageCutoffNotMet(languageProfile, currentLanguage))
{
return(true);
}
if (QualityCutoffNotMet(profile, currentQuality, newQuality))
{
return(true);
}
if (IsPreferredWordUpgradable(currentScore, newScore))
{
return(true);
}
_logger.Debug("Existing item meets cut-off. skipping.");
return(false);
}
static void Main(string[] args)
{
LanguageDetector langDet = LanguageDetector.GetLanguageDetectorPrebuilt();
//LanguageDetector langDet = new LanguageDetector();
//langDet.ReadCorpus(@"C:\Users\mIHA\Desktop\langdet");
LanguageProfile p = langDet.FindMatchingLanguage("To je slovenski stavek. Čeprav ga naš detektor ne zazna pravilno. Mogoče šumniki pomagajo...");
Console.WriteLine(p.Language);
p = langDet.FindMatchingLanguage("I love you.");
Console.WriteLine(p.Language);
p = langDet.FindMatchingLanguage("Baš te volim.");
Console.WriteLine(p.Language);
p = langDet.FindMatchingLanguage("Je t'aime.");
Console.WriteLine(p.Language);
foreach (LanguageProfile pr in langDet.LanguageProfiles)
{
BinarySerializer ser = new BinarySerializer(string.Format(@"C:\Users\mIHA\Desktop\langdet\{0}.ldp", pr.Language), FileMode.Create);
pr.Save(ser);
ser.Close();
}
//Console.WriteLine(langDet.GetLanguageProfile("et"));
//StreamWriter w = new StreamWriter("c:\\krneki\\langSim.txt");
//foreach (LanguageProfile p in langDet.LanguageProfiles)
//{
// w.Write("{0}\t", p.Code);
//}
//w.WriteLine();
//foreach (LanguageProfile p in langDet.LanguageProfiles)
//{
// foreach (LanguageProfile p2 in langDet.LanguageProfiles)
// {
// //w.Write("{0}\t", Math.Max(p.CalcSpearman(p2), p2.CalcSpearman(p)));
// }
// w.WriteLine();
//}
//w.Close();
}
public void should_return_false_if_release_and_existing_file_are_the_same()
{
var profile = new QualityProfile
{
Items = Qualities.QualityFixture.GetDefaultQualities(),
};
var langProfile = new LanguageProfile
{
Languages = LanguageFixture.GetDefaultLanguages(),
Cutoff = Language.English
};
Subject.IsUpgradable(
profile,
langProfile,
new QualityModel(Quality.HDTV720p, new Revision(version: 1)),
Language.English,
NoPreferredWordScore,
new QualityModel(Quality.HDTV720p, new Revision(version: 1)),
Language.English,
NoPreferredWordScore)
.Should().BeFalse();
}
public override bool Execute()
{
try
{
string json = File.ReadAllText(InputFilename);
JsonLanguageProfile jsonProfile = JsonConvert.DeserializeObject<JsonLanguageProfile>(json);
LanguageProfile profile = new LanguageProfile();
profile.Code = jsonProfile.name;
profile.Frequencies = jsonProfile.freq;
profile.WordCount = jsonProfile.n_words;
using (Stream stream = new FileStream(OutputFilename, FileMode.Create, FileAccess.Write))
using (Stream compressedStream = new GZipStream(stream, CompressionMode.Compress))
profile.Save(compressedStream);
return true;
}
catch (Exception e)
{
Log.LogErrorFromException(e);
return false;
}
}
