public IEnumerable <PythonPackage> FindInstalledPackages(string name, string required_version, Request request)
{
/* FIXME: optimize if name and required_version are specified. */
string path = global_site_folder;
string name_wc = string.IsNullOrWhiteSpace(name) ? "*" : name;
string version_wc = string.IsNullOrWhiteSpace(required_version) ? "*" : required_version;
request.Debug("Python::FindInstalledPackages searching {0}", path);
foreach (string dir in Directory.EnumerateDirectories(path, string.Format("{0}-{1}.dist-info", name_wc, version_wc)))
{
request.Debug("Python::FindInstalledPackages trying {0}", dir);
PythonPackage result = PythonPackage.FromDistInfo(dir, this, request);
if (result != null)
{
if (!string.IsNullOrWhiteSpace(name) && !result.MatchesName(name))
{
continue;
}
yield return(result);
}
}
foreach (string dir in Directory.EnumerateDirectories(path, string.Format("{0}-{1}-*.egg-info", name_wc, version_wc)))
{
request.Debug("Python::FindInstalledPackages trying {0}", dir);
PythonPackage result = PythonPackage.FromEggInfo(dir, this, request);
if (result != null)
{
if (!string.IsNullOrWhiteSpace(name) && !result.MatchesName(name))
{
continue;
}
yield return(result);
}
}
}
public static PythonPackage GetPackage(Tuple <string, string> source, string name, string version, Request request)
{
var detailed_info = GetDetailedPackageInfo(source, name, version, request);
PythonPackage package = new PythonPackage(name);
package.version = new VersionIdentifier(version);
package.summary = detailed_info["info"]["summary"].ToString();
package.source = source.Item1;
package.sourceurl = source.Item2;
package.search_key = name;
package.downloads = ParseUrls(detailed_info["urls"]);
JToken requires_dist;
if (((JObject)detailed_info["info"]).TryGetValue("requires_dist", out requires_dist))
{
foreach (var requirement in requires_dist)
{
package.requires_dist.Add(DistRequirement.Parse(requirement.ToString()));
}
}
if (((JObject)detailed_info["info"]).TryGetValue("requires", out requires_dist))
{
foreach (var requirement in requires_dist)
{
package.requires_dist.Add(DistRequirement.Parse(requirement.ToString()));
}
}
return(package);
}
public void FindPackageByFile(string file, int id, Request request)
{
request.Debug("Calling '{0}::FindPackageByFile' '{1}','{2}'", ProviderName, file, id);
foreach (var package in PythonPackage.PackagesFromFile(file, request))
{
package.YieldSelf(request);
}
}
public static PythonPackage FromEggInfo(string path, PythonInstall install, Request request)
{
var result = new PythonPackage(null);
result.status = Constants.PackageStatus.Installed;
result.egginfo_path = path;
result.install = install;
try
{
result.ReadMetadata(Path.Combine(path, "PKG-INFO"));
}
catch (Exception e)
{
request.Debug(string.Format("Unexpected Exception thrown in 'Python::FromEggInfo' -- {1}\\{2}\r\n{3}"), e.GetType().Name, e.Message, e.StackTrace);
}
if (result.name != null)
{
return(result);
}
return(null);
}
private static bool InstallDependencies(PythonInstall install, Dictionary <string, PythonPackage> deps, Request request)
{
while (deps.Count != 0)
{
var enumerator = deps.GetEnumerator();
enumerator.MoveNext();
PythonPackage package = enumerator.Current.Value;
bool unsatisfied_deps = true;
while (unsatisfied_deps)
{
unsatisfied_deps = false;
foreach (var dep in package.requires_dist)
{
if (dep.marker != null && !dep.marker.Eval(install))
{
continue;
}
if (deps.ContainsKey(NormalizeName(dep.name)))
{
// FIXME: Infinite loop if dep graph has cycles
package = deps[NormalizeName(dep.name)];
unsatisfied_deps = true;
break;
}
}
}
if (!package.Install(install, request))
{
return(false);
}
deps.Remove(NormalizeName(package.name));
}
return(true);
}
public void UninstallPackage(string fastPackageReference, Request request)
{
var package = PythonPackage.FromFastReference(fastPackageReference, request);
package.Uninstall(request);
}
public void InstallPackage(string fastPackageReference, Request request)
{
request.Debug("Calling '{0}::InstallPackage' '{1}'", ProviderName, fastPackageReference);
var package = PythonPackage.FromFastReference(fastPackageReference, request);
if (package is PythonInstall)
{
((PythonInstall)package).Install(request);
return;
}
bool retried = false;
retry:
List <PythonInstall> usableinstalls = new List <PythonInstall>();
List <PythonInstall> unusableinstalls = new List <PythonInstall>();
foreach (var candidateinstall in PythonInstall.FindEnvironments(request))
{
if (package.CanInstall(candidateinstall, request))
{
usableinstalls.Add(candidateinstall);
}
else
{
unusableinstalls.Add(candidateinstall);
}
}
if (usableinstalls.Count == 1)
{
package.Install(usableinstalls[0], request);
}
else if (usableinstalls.Count == 0)
{
// Need to install a Python
if (retried)
{
request.Error(ErrorCategory.NotImplemented, package.name, "Failed to install a Python interpreter");
return;
}
List <PythonPackage> candidate_pythons = new List <PythonPackage>(
PythonWebsite.Search("Python", null, null, null, true, request));
candidate_pythons.Sort(new PackageVersionComparer());
bool installed = false;
for (int i = candidate_pythons.Count - 1; i >= 0; i--)
{
if (Environment.Is64BitOperatingSystem &&
((PythonInstall)candidate_pythons[i]).CanInstall(true, request) &&
package.CanInstall((PythonInstall)candidate_pythons[i], true, request))
{
((PythonInstall)candidate_pythons[i]).Install(true, request);
installed = true;
break;
}
else if (((PythonInstall)candidate_pythons[i]).CanInstall(false, request) &&
package.CanInstall((PythonInstall)candidate_pythons[i], true, request))
{
((PythonInstall)candidate_pythons[i]).Install(false, request);
installed = true;
break;
}
}
if (installed)
{
retried = true;
goto retry;
}
else
{
request.Error(ErrorCategory.NotImplemented, package.name, "Couldn't find a Python interpreter to install for this");
return;
}
}
else if (usableinstalls.Count > 1)
{
if (request.GetOptionValue("Force") == "True")
{
PythonInstall greatest = usableinstalls[0];
foreach (var candidate in usableinstalls)
{
if (candidate.version.Compare(greatest.version) > 0)
{
greatest = candidate;
}
}
package.Install(greatest, request);
}
else
{
request.Warning("Multiple installed Python interpreters could satisfy this request:");
foreach (var install in usableinstalls)
{
request.Warning(" Python version '{0}' at '{1}'", install.version, install.exe_path);
}
request.Warning("Please select a Python to install to, using e.g. -PythonVersion 3.2 or -PythonLocation c:\\python32\\python.exe");
request.Error(ErrorCategory.NotSpecified, package.name, "Not enough information to select a Python interpreter for the install");
}
}
}
public static IEnumerable <PythonPackage> PackagesFromFile(string path, Request request)
{
Stream inputstream = null;
try
{
inputstream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
}
catch (Exception e) {
request.Debug("Failed to open {0}: {1}", path, e);
goto end;
}
using (inputstream)
{
ZipFile zf = null;
try
{
inputstream.Seek(0, SeekOrigin.Begin);
zf = new ZipFile(inputstream);
zf.IsStreamOwner = false;
}
catch (Exception e)
{
request.Debug("Failed to open {0} as zip: {1}", path, e);
goto notzip;
}
using (zf)
{
foreach (ZipEntry ze in zf)
{
if (ze.Name.EndsWith(".dist-info/METADATA"))
{
string distinfoname = ze.Name.Substring(0, ze.Name.Length - 9);
if (distinfoname.Contains("/"))
{
// just so we know we can use these in fastpath
continue;
}
var result = new PythonPackage(null);
result.status = Constants.PackageStatus.Available;
result.archive_path = path;
using (var metadata_stream = zf.GetInputStream(ze))
{
result.ReadMetadata(metadata_stream);
}
using (var wheel_metadata_stream = zf.GetInputStream(zf.GetEntry(string.Format("{0}/WHEEL", distinfoname))))
{
result.ReadWheelMetadata(wheel_metadata_stream);
}
if (string.Compare(distinfoname,
string.Format("{0}-{1}.dist-info", escape_package_name(result.name), result.version.raw_version_string),
true, CultureInfo.InvariantCulture) != 0)
{
continue;
}
result.is_wheel = true;
yield return(result);
}
}
}
notzip : do
{
} while (false); // Labels must be followed by a statement
}
end : do
{
} while (false); // Labels must be followed by a statement
}
private static IEnumerable <PythonPackage> FilterPackageVersions(Tuple <string, string> source,
string search_name, string package_name, HashSet <string> nonhidden_versions,
VersionIdentifier required, VersionIdentifier minimum, VersionIdentifier maximum,
bool no_filter, Request request)
{
JObject detailed_info;
try
{
detailed_info = GetDetailedPackageInfo(source, package_name, null, request);
}
catch (WebException)
{
/* Sometimes the search API lists things that 404 */
goto end;
}
bool list_all_versions = (no_filter || request.GetOptionValue("AllVersions") == "True");
var release_listing = detailed_info.GetValue("releases") as JObject;
List <string> sorted_versions = new List <string>();
foreach (var release in release_listing)
{
sorted_versions.Add(release.Key);
}
sorted_versions.Sort(delegate(string a, string b)
{
// sort nonhidden versions first
if (nonhidden_versions.Contains(a))
{
if (!nonhidden_versions.Contains(b))
{
return(-1);
}
}
else if (!nonhidden_versions.Contains(a))
{
if (nonhidden_versions.Contains(b))
{
return(1);
}
}
// sort non-prerelease versions first
VersionIdentifier va = new VersionIdentifier(a);
VersionIdentifier vb = new VersionIdentifier(b);
if (va.IsPrerelease && !vb.IsPrerelease)
{
return(1);
}
if (!va.IsPrerelease && vb.IsPrerelease)
{
return(-1);
}
// newer versions first
return(vb.Compare(va));
});
foreach (var version in sorted_versions)
{
VersionIdentifier candidate_version = new VersionIdentifier(version);
var uris = release_listing[version] as JArray;
if (uris == null || uris.Count == 0)
{
continue;
}
if (required != null && required.Compare(candidate_version) != 0)
{
continue;
}
if (minimum != null && minimum.Compare(candidate_version) > 0)
{
continue;
}
if (maximum != null && maximum.Compare(candidate_version) < 0)
{
continue;
}
PythonPackage package = new PythonPackage(package_name);
package.version = new VersionIdentifier(version);
package.summary = detailed_info["info"]["summary"].ToString();
package.source = source.Item1;
package.sourceurl = source.Item2;
package.search_key = search_name;
package.downloads = ParseUrls(uris);
package.incomplete_metadata = true;
yield return(package);
if (!list_all_versions)
{
break;
}
}
end : do
{
} while (false); /* labels require a statement */
}
