Rename category to kind (#91)

Author: DonJayamanne

crates/pet-conda/src/environments.rs

@@ -10,7 +10,7 @@ use log::warn;
 use pet_core::{
     arch::Architecture,
     manager::EnvManager,
-    python_environment::{PythonEnvironment, PythonEnvironmentBuilder, PythonEnvironmentCategory},
+    python_environment::{PythonEnvironment, PythonEnvironmentBuilder, PythonEnvironmentKind},
 };
 use pet_fs::path::{norm_case, resolve_symlink};
 use pet_python_utils::executable::{find_executable, find_executables};
@@ -57,7 +57,7 @@ impl CondaEnvironment {
             }
         }
         // This is a root env.
-        let builder = PythonEnvironmentBuilder::new(PythonEnvironmentCategory::Conda)
+        let builder = PythonEnvironmentBuilder::new(PythonEnvironmentKind::Conda)
             .executable(self.executable.clone())
             .version(self.version.clone())
             .prefix(Some(self.prefix.clone()))

crates/pet-conda/src/lib.rs

@@ -9,7 +9,7 @@ use log::{error, warn};
 use manager::CondaManager;
 use pet_core::{
     os_environment::Environment,
-    python_environment::{PythonEnvironment, PythonEnvironmentCategory},
+    python_environment::{PythonEnvironment, PythonEnvironmentKind},
     reporter::Reporter,
     Locator, LocatorResult,
 };
@@ -149,8 +149,8 @@ impl Locator for Conda {
     fn get_name(&self) -> &'static str {
         "Conda"
     }
-    fn supported_categories(&self) -> Vec<PythonEnvironmentCategory> {
-        vec![PythonEnvironmentCategory::Conda]
+    fn supported_categories(&self) -> Vec<PythonEnvironmentKind> {
+        vec![PythonEnvironmentKind::Conda]
     }
     fn try_from(&self, env: &PythonEnv) -> Option<PythonEnvironment> {
         // Possible we do not have the prefix, but this exe is in the bin directory and its a conda env or root conda install.

crates/pet-conda/tests/ci_test.rs

@@ -26,7 +26,7 @@ fn detect_conda_root() {
     use pet_conda::Conda;
     use pet_core::{
         manager::EnvManagerType, os_environment::EnvironmentApi,
-        python_environment::PythonEnvironmentCategory, Locator,
+        python_environment::PythonEnvironmentKind, Locator,
     };
     use pet_reporter::test::create_reporter;
 
@@ -54,7 +54,7 @@ fn detect_conda_root() {
         .unwrap();
     assert_eq!(env.prefix, conda_dir.clone().into());
     assert_eq!(env.name, Some("base".into()));
-    assert_eq!(env.category, PythonEnvironmentCategory::Conda);
+    assert_eq!(env.kind, PythonEnvironmentKind::Conda);
     assert_eq!(env.executable, Some(conda_dir.join("bin").join("python")));
     assert_eq!(env.version, Some(get_version(&info.python_version)));
 
@@ -69,7 +69,7 @@ fn detect_conda_root_from_path() {
     use pet_conda::Conda;
     use pet_core::{
         manager::EnvManagerType, os_environment::EnvironmentApi,
-        python_environment::PythonEnvironmentCategory, Locator,
+        python_environment::PythonEnvironmentKind, Locator,
     };
     use pet_python_utils::env::PythonEnv;
     use std::path::PathBuf;
@@ -93,7 +93,7 @@ fn detect_conda_root_from_path() {
 
     assert_eq!(env.prefix, conda_dir.clone().into());
     assert_eq!(env.name, Some("base".into()));
-    assert_eq!(env.category, PythonEnvironmentCategory::Conda);
+    assert_eq!(env.kind, PythonEnvironmentKind::Conda);
     assert_eq!(env.executable, Some(conda_dir.join("bin").join("python")));
     assert_eq!(env.version, Some(get_version(&info.python_version)));
 }
@@ -105,7 +105,7 @@ fn detect_conda_root_from_path() {
 fn detect_new_conda_env() {
     use pet_conda::Conda;
     use pet_core::{
-        os_environment::EnvironmentApi, python_environment::PythonEnvironmentCategory, Locator,
+        os_environment::EnvironmentApi, python_environment::PythonEnvironmentKind, Locator,
     };
     use pet_reporter::test::create_reporter;
     use std::path::PathBuf;
@@ -144,7 +144,7 @@ fn detect_new_conda_env() {
     let prefix = conda_dir.clone().join("envs").join(env_name);
     assert_eq!(env.prefix, prefix.clone().into());
     assert_eq!(env.name, Some(env_name.into()));
-    assert_eq!(env.category, PythonEnvironmentCategory::Conda);
+    assert_eq!(env.kind, PythonEnvironmentKind::Conda);
     assert_eq!(env.executable, prefix.join("bin").join("python").into());
     assert!(
         env.version.clone().unwrap_or_default().starts_with("3.10"),
@@ -163,7 +163,7 @@ fn detect_conda_env_from_path() {
     use pet_conda::Conda;
     use pet_core::{
         manager::EnvManagerType, os_environment::EnvironmentApi,
-        python_environment::PythonEnvironmentCategory, Locator,
+        python_environment::PythonEnvironmentKind, Locator,
     };
     use pet_python_utils::env::PythonEnv;
     use std::path::PathBuf;
@@ -193,7 +193,7 @@ fn detect_conda_env_from_path() {
 
     assert_eq!(env.prefix, prefix.clone().into());
     assert_eq!(env.name, Some(env_name.into()));
-    assert_eq!(env.category, PythonEnvironmentCategory::Conda);
+    assert_eq!(env.kind, PythonEnvironmentKind::Conda);
     assert_eq!(env.executable, exe.clone().into());
     assert!(
         env.version.clone().unwrap_or_default().starts_with("3.10"),
@@ -209,7 +209,7 @@ fn detect_conda_env_from_path() {
 fn detect_new_conda_env_without_python() {
     use pet_conda::Conda;
     use pet_core::{
-        os_environment::EnvironmentApi, python_environment::PythonEnvironmentCategory, Locator,
+        os_environment::EnvironmentApi, python_environment::PythonEnvironmentKind, Locator,
     };
     use pet_reporter::test::create_reporter;
     use std::path::PathBuf;
@@ -245,7 +245,7 @@ fn detect_new_conda_env_without_python() {
     let prefix = conda_dir.clone().join("envs").join(env_name);
     assert_eq!(env.prefix, prefix.clone().into());
     assert_eq!(env.name, Some(env_name.into()));
-    assert_eq!(env.category, PythonEnvironmentCategory::Conda);
+    assert_eq!(env.kind, PythonEnvironmentKind::Conda);
     assert_eq!(env.executable.is_none(), true);
     assert_eq!(env.version.is_none(), true);
 
@@ -260,7 +260,7 @@ fn detect_new_conda_env_created_with_p_flag_without_python() {
     use common::resolve_test_path;
     use pet_conda::Conda;
     use pet_core::{
-        os_environment::EnvironmentApi, python_environment::PythonEnvironmentCategory, Locator,
+        os_environment::EnvironmentApi, python_environment::PythonEnvironmentKind, Locator,
     };
     use pet_reporter::test::create_reporter;
 
@@ -293,7 +293,7 @@ fn detect_new_conda_env_created_with_p_flag_without_python() {
 
     assert_eq!(env.prefix, prefix.clone().into());
     assert_eq!(env.name, None);
-    assert_eq!(env.category, PythonEnvironmentCategory::Conda);
+    assert_eq!(env.kind, PythonEnvironmentKind::Conda);
     assert_eq!(env.executable.is_none(), true);
     assert_eq!(env.version.is_none(), true);
 
@@ -308,7 +308,7 @@ fn detect_new_conda_env_created_with_p_flag_with_python() {
     use common::resolve_test_path;
     use pet_conda::Conda;
     use pet_core::{
-        os_environment::EnvironmentApi, python_environment::PythonEnvironmentCategory, Locator,
+        os_environment::EnvironmentApi, python_environment::PythonEnvironmentKind, Locator,
     };
     use pet_reporter::test::create_reporter;
 
@@ -345,7 +345,7 @@ fn detect_new_conda_env_created_with_p_flag_with_python() {
 
     assert_eq!(env.prefix, prefix.clone().into());
     assert_eq!(env.name, None);
-    assert_eq!(env.category, PythonEnvironmentCategory::Conda);
+    assert_eq!(env.kind, PythonEnvironmentKind::Conda);
     assert_eq!(env.executable, exe.into());
     assert!(
         env.version.clone().unwrap_or_default().starts_with("3.10"),

crates/pet-conda/tests/lib_test.rs

@@ -8,9 +8,7 @@ mod common;
 fn find_conda_env_without_manager() {
     use common::{create_test_environment, resolve_test_path};
     use pet_conda::Conda;
-    use pet_core::{
-        self, arch::Architecture, python_environment::PythonEnvironmentCategory, Locator,
-    };
+    use pet_core::{self, arch::Architecture, python_environment::PythonEnvironmentKind, Locator};
     use pet_python_utils::env::PythonEnv;
     use std::collections::HashMap;
 
@@ -28,7 +26,7 @@ fn find_conda_env_without_manager() {
 
     assert_eq!(env.prefix, path.clone().into());
     assert_eq!(env.arch, Architecture::X64.into());
-    assert_eq!(env.category, PythonEnvironmentCategory::Conda);
+    assert_eq!(env.kind, PythonEnvironmentKind::Conda);
     assert_eq!(env.executable, path.join("bin").join("python").into());
     assert_eq!(env.version, "3.12.2".to_string().into());
     assert_eq!(env.manager, None);
@@ -40,9 +38,7 @@ fn find_conda_env_without_manager() {
 fn find_conda_env_without_manager_but_detect_manager_from_history() {
     use common::{create_test_environment, resolve_test_path};
     use pet_conda::Conda;
-    use pet_core::{
-        self, arch::Architecture, python_environment::PythonEnvironmentCategory, Locator,
-    };
+    use pet_core::{self, arch::Architecture, python_environment::PythonEnvironmentKind, Locator};
     use pet_python_utils::env::PythonEnv;
     use std::{
         collections::HashMap,
@@ -79,7 +75,7 @@ fn find_conda_env_without_manager_but_detect_manager_from_history() {
 
     assert_eq!(env.prefix, path.clone().into());
     assert_eq!(env.arch, Architecture::X64.into());
-    assert_eq!(env.category, PythonEnvironmentCategory::Conda);
+    assert_eq!(env.kind, PythonEnvironmentKind::Conda);
     assert_eq!(env.executable, path.join("bin").join("python").into());
     assert_eq!(env.version, "3.12.2".to_string().into());
     assert_eq!(

crates/pet-core/src/lib.rs

@@ -5,7 +5,7 @@ use std::path::PathBuf;
 
 use manager::EnvManager;
 use pet_python_utils::env::PythonEnv;
-use python_environment::{PythonEnvironment, PythonEnvironmentCategory};
+use python_environment::{PythonEnvironment, PythonEnvironmentKind};
 use reporter::Reporter;
 
 pub mod arch;
@@ -40,7 +40,7 @@ pub trait Locator: Send + Sync {
         //
     }
     /// Returns a list of supported categories for this locator.
-    fn supported_categories(&self) -> Vec<PythonEnvironmentCategory>;
+    fn supported_categories(&self) -> Vec<PythonEnvironmentKind>;
     /// Given a Python executable, and some optional data like prefix,
     /// this method will attempt to convert it to a PythonEnvironment that can be supported by this particular locator.
     /// If an environment is not supported by this locator, then None is returned.

crates/pet-core/src/python_environment.rs

@@ -9,7 +9,7 @@ use std::path::PathBuf;
 use crate::{arch::Architecture, manager::EnvManager};
 
 #[derive(Serialize, Deserialize, Clone, Copy, PartialEq, Eq, Debug, Hash)]
-pub enum PythonEnvironmentCategory {
+pub enum PythonEnvironmentKind {
     Conda,
     Homebrew,
     Pyenv,           // Relates to Python installations in pyenv that are from Python org.
@@ -28,12 +28,12 @@ pub enum PythonEnvironmentCategory {
     WindowsStore,
     WindowsRegistry,
 }
-impl Ord for PythonEnvironmentCategory {
+impl Ord for PythonEnvironmentKind {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
         format!("{self:?}").cmp(&format!("{other:?}"))
     }
 }
-impl PartialOrd for PythonEnvironmentCategory {
+impl PartialOrd for PythonEnvironmentKind {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
         Some(self.cmp(other))
     }
@@ -51,7 +51,7 @@ pub struct PythonEnvironment {
     pub name: Option<String>,
     // Python executable, can be empty in the case of conda envs that do not have Python installed in them.
     pub executable: Option<PathBuf>,
-    pub category: PythonEnvironmentCategory,
+    pub kind: PythonEnvironmentKind,
     pub version: Option<String>,
     // SysPrefix for the environment.
     pub prefix: Option<PathBuf>,
@@ -102,7 +102,7 @@ impl Default for PythonEnvironment {
             // Sometimes we might not know the env type.
             // Lets never default these to System/Global or others as thats not true.
             // Not knowing does not mean it is a system env.
-            category: PythonEnvironmentCategory::Unknown,
+            kind: PythonEnvironmentKind::Unknown,
             version: None,
             prefix: None,
             manager: None,
@@ -117,14 +117,14 @@ impl Default for PythonEnvironment {
 impl PythonEnvironment {
     pub fn new(
         executable: Option<PathBuf>,
-        category: PythonEnvironmentCategory,
+        kind: PythonEnvironmentKind,
         prefix: Option<PathBuf>,
         manager: Option<EnvManager>,
         version: Option<String>,
     ) -> Self {
         Self {
             executable,
-            category,
+            kind,
             version,
             prefix,
             manager,
@@ -135,7 +135,7 @@ impl PythonEnvironment {
 
 impl std::fmt::Display for PythonEnvironment {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        writeln!(f, "Environment ({:?})", self.category).unwrap_or_default();
+        writeln!(f, "Environment ({:?})", self.kind).unwrap_or_default();
         if let Some(name) = &self.display_name {
             writeln!(f, "   Display-Name: {name}").unwrap_or_default();
         }
@@ -205,7 +205,7 @@ pub struct PythonEnvironmentBuilder {
     display_name: Option<String>,
     name: Option<String>,
     executable: Option<PathBuf>,
-    category: PythonEnvironmentCategory,
+    kind: PythonEnvironmentKind,
     version: Option<String>,
     prefix: Option<PathBuf>,
     manager: Option<EnvManager>,
@@ -216,9 +216,9 @@ pub struct PythonEnvironmentBuilder {
 }
 
 impl PythonEnvironmentBuilder {
-    pub fn new(category: PythonEnvironmentCategory) -> Self {
+    pub fn new(kind: PythonEnvironmentKind) -> Self {
         Self {
-            category,
+            kind,
             display_name: None,
             name: None,
             executable: None,
@@ -314,7 +314,7 @@ impl PythonEnvironmentBuilder {
         };
         if let Some(executable) = &self.executable {
             self.executable = Some(
-                get_shortest_executable(&self.category, &Some(all.clone()))
+                get_shortest_executable(&self.kind, &Some(all.clone()))
                     .unwrap_or(executable.clone()),
             );
         }
@@ -337,14 +337,14 @@ impl PythonEnvironmentBuilder {
             Some(all.clone())
         };
         let executable = self.executable.map(|executable| {
-            get_shortest_executable(&self.category, &Some(all.clone())).unwrap_or(executable)
+            get_shortest_executable(&self.kind, &Some(all.clone())).unwrap_or(executable)
         });
 
         PythonEnvironment {
             display_name: self.display_name,
             name: self.name,
             executable,
-            category: self.category,
+            kind: self.kind,
             version: self.version,
             prefix: self.prefix,
             manager: self.manager,
@@ -359,11 +359,11 @@ impl PythonEnvironmentBuilder {
 // Given a list of executables, return the one with the shortest path.
 // The shortest path is the most likely to be most user friendly.
 fn get_shortest_executable(
-    category: &PythonEnvironmentCategory,
+    kind: &PythonEnvironmentKind,
     exes: &Option<Vec<PathBuf>>,
 ) -> Option<PathBuf> {
     // For windows store, the exe should always be the one in the WindowsApps folder.
-    if *category == PythonEnvironmentCategory::WindowsStore {
+    if *kind == PythonEnvironmentKind::WindowsStore {
         if let Some(exes) = exes {
             if let Some(exe) = exes.iter().find(|e| {
                 e.to_string_lossy().contains("AppData")
@@ -398,7 +398,7 @@ pub fn get_environment_key(env: &PythonEnvironment) -> Option<PathBuf> {
         Some(exe.clone())
     } else if let Some(prefix) = &env.prefix {
         // If this is a conda env without Python, then the exe will be prefix/bin/python
-        if env.category == PythonEnvironmentCategory::Conda {
+        if env.kind == PythonEnvironmentKind::Conda {
             Some(prefix.join("bin").join(if cfg!(windows) {
                 "python.exe"
             } else {

crates/pet-core/src/telemetry/inaccurate_python_info.rs

@@ -1,14 +1,14 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::python_environment::PythonEnvironmentCategory;
+use crate::python_environment::PythonEnvironmentKind;
 
 /// Information about an environment that was discovered to be inaccurate.
 /// If the discovered information is None, then it means that the information was not found.
 /// And we will not report that as an inaccuracy.
 pub struct InaccuratePythonEnvironmentInfo {
-    /// Python Env category
-    pub category: PythonEnvironmentCategory,
+    /// Python Env kind
+    pub kind: PythonEnvironmentKind,
     /// Whether the actual exe is not what we expected.
     pub invalid_executable: Option<bool>,
     /// Whether the actual exe was not even in the list of symlinks that we expected.
@@ -23,7 +23,7 @@ pub struct InaccuratePythonEnvironmentInfo {
 
 impl std::fmt::Display for InaccuratePythonEnvironmentInfo {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        writeln!(f, "Environment {:?} incorrectly identified", self.category).unwrap_or_default();
+        writeln!(f, "Environment {:?} incorrectly identified", self.kind).unwrap_or_default();
         if self.invalid_executable.unwrap_or_default() {
             writeln!(f, "   Executable is incorrect").unwrap_or_default();
         }