koava 0.1.0__tar.gz → 0.1.1__tar.gz

{koava-0.1.0 → koava-0.1.1}/.github/workflows/koava-release.yml

@@ -177,12 +177,58 @@ jobs:
         echo "Is Release: $IS_RELEASE"
         echo "=============================="
     
-    - name: Update versions in files
+    - name: Check versions in files
       run: |
-        VERSION="${{ steps.config.outputs.version }}"
-        sed -i "s/^version = \".*\"/version = \"$VERSION\"/" pyproject.toml
-        sed -i "s/^version = \".*\"/version = \"$VERSION\"/" Cargo.toml
-        echo "Updated pyproject.toml and Cargo.toml version to $VERSION"
+        EVENT_NAME="${{ github.event_name }}"
+        REF_TYPE="${{ github.ref_type }}"
+        IS_TAG_PUSH=false
+        
+        if [ "$EVENT_NAME" = "push" ] && [ "$REF_TYPE" = "tag" ]; then
+          IS_TAG_PUSH=true
+          TAG_NAME="${{ github.ref_name }}"
+          TAG_VERSION="${TAG_NAME#v}"
+        fi
+        
+        # Extract version from Cargo.toml
+        CARGO_VERSION=$(grep -E '^version = ' Cargo.toml | sed -E 's/^version = "([^"]+)"/\1/')
+        
+        # Extract version from pyproject.toml
+        PYPROJECT_VERSION=$(grep -E '^version = ' pyproject.toml | sed -E 's/^version = "([^"]+)"/\1/')
+        
+        echo "=== Version Check ==="
+        echo "Cargo.toml version: $CARGO_VERSION"
+        echo "pyproject.toml version: $PYPROJECT_VERSION"
+        
+        if [ "$IS_TAG_PUSH" = "true" ]; then
+          echo "Tag version: $TAG_VERSION"
+          echo ""
+          echo "Checking three-way version match (Cargo.toml, pyproject.toml, and tag)..."
+          
+          # Check if all three versions match
+          if [ "$CARGO_VERSION" != "$PYPROJECT_VERSION" ]; then
+            echo "::error::Version mismatch: Cargo.toml has '$CARGO_VERSION' but pyproject.toml has '$PYPROJECT_VERSION'"
+            exit 1
+          fi
+          
+          if [ "$CARGO_VERSION" != "$TAG_VERSION" ]; then
+            echo "::error::Version mismatch: Cargo.toml/pyproject.toml have '$CARGO_VERSION' but tag has '$TAG_VERSION'"
+            exit 1
+          fi
+          
+          echo "✓ All three versions match: $CARGO_VERSION"
+        else
+          echo ""
+          echo "Checking two-way version match (Cargo.toml and pyproject.toml)..."
+          
+          # Check if Cargo.toml and pyproject.toml versions match
+          if [ "$CARGO_VERSION" != "$PYPROJECT_VERSION" ]; then
+            echo "::error::Version mismatch: Cargo.toml has '$CARGO_VERSION' but pyproject.toml has '$PYPROJECT_VERSION'"
+            exit 1
+          fi
+          
+          echo "✓ Both files have the same version: $CARGO_VERSION"
+        fi
+        echo "===================="
 
   build-linux-x86_64:
     needs: prepare
@@ -211,12 +257,6 @@ jobs:
     - name: Install maturin
       run: pip install maturin
 
-    - name: Update versions
-      run: |
-        VERSION="${{ needs.prepare.outputs.version }}"
-        sed -i "s/^version = \".*\"/version = \"$VERSION\"/" pyproject.toml
-        sed -i "s/^version = \".*\"/version = \"$VERSION\"/" Cargo.toml
-    
     - name: Build for Linux x86_64
       run: maturin build --release --target x86_64-unknown-linux-gnu --features cert-pinning
     
@@ -270,12 +310,6 @@ jobs:
     - name: Install maturin
       run: pip install maturin
 
-    - name: Update versions
-      run: |
-        VERSION="${{ needs.prepare.outputs.version }}"
-        sed -i "s/^version = \".*\"/version = \"$VERSION\"/" pyproject.toml
-        sed -i "s/^version = \".*\"/version = \"$VERSION\"/" Cargo.toml
-    
     - name: Build for Linux ARM64
       run: maturin build --release --target aarch64-unknown-linux-gnu --features cert-pinning
     
@@ -307,12 +341,6 @@ jobs:
     - name: Install maturin
       run: pip install maturin
 
-    - name: Update versions
-      run: |
-        VERSION="${{ needs.prepare.outputs.version }}"
-        sed -i '' "s/^version = \".*\"/version = \"$VERSION\"/" pyproject.toml
-        sed -i '' "s/^version = \".*\"/version = \"$VERSION\"/" Cargo.toml
-    
     - name: Build for macOS x86_64
       run: maturin build --release --target x86_64-apple-darwin --features cert-pinning
     
@@ -343,12 +371,6 @@ jobs:
     
     - name: Install maturin
       run: pip install maturin
-    
-    - name: Update versions
-      run: |
-        VERSION="${{ needs.prepare.outputs.version }}"
-        sed -i '' "s/^version = \".*\"/version = \"$VERSION\"/" pyproject.toml
-        sed -i '' "s/^version = \".*\"/version = \"$VERSION\"/" Cargo.toml
 
     - name: Build for macOS ARM64
       run: maturin build --release --target aarch64-apple-darwin --features cert-pinning
@@ -380,13 +402,6 @@ jobs:
     
     - name: Install maturin
       run: pip install maturin
-    
-    - name: Update versions
-      shell: pwsh
-      run: |
-        $version = "${{ needs.prepare.outputs.version }}"
-        (Get-Content pyproject.toml) -replace '^version = ".*"', "version = `"$version`"" | Set-Content pyproject.toml
-        (Get-Content Cargo.toml) -replace '^version = ".*"', "version = `"$version`"" | Set-Content Cargo.toml
 
     - name: Build for Windows x64
       run: maturin build --release --target x86_64-pc-windows-msvc --features cert-pinning
@@ -418,13 +433,6 @@ jobs:
     
     - name: Install maturin
       run: pip install maturin
-    
-    - name: Update versions
-      shell: pwsh
-      run: |
-        $version = "${{ needs.prepare.outputs.version }}"
-        (Get-Content pyproject.toml) -replace '^version = ".*"', "version = `"$version`"" | Set-Content pyproject.toml
-        (Get-Content Cargo.toml) -replace '^version = ".*"', "version = `"$version`"" | Set-Content Cargo.toml
 
     - name: Build for Windows ARM64
       run: maturin build --release --target aarch64-pc-windows-msvc --features cert-pinning
@@ -458,12 +466,6 @@ jobs:
     - name: Install maturin
       run: pip install maturin
     
-    - name: Update versions
-      run: |
-        VERSION="${{ needs.prepare.outputs.version }}"
-        sed -i "s/^version = \".*\"/version = \"$VERSION\"/" pyproject.toml
-        sed -i "s/^version = \".*\"/version = \"$VERSION\"/" Cargo.toml
-    
     - name: Build source distribution (sdist)
       run: maturin sdist
     

{koava-0.1.0 → koava-0.1.1}/Cargo.lock

@@ -1567,7 +1567,7 @@ dependencies = [
 
 [[package]]
 name = "koava"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "anyhow",
  "base64 0.22.1",

{koava-0.1.0 → koava-0.1.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "koava"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 description = "KoalaVault model converter tool for producers"
 authors = ["KoalaVault Team"]

{koava-0.1.0 → koava-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koava
-Version: 0.1.0
+Version: 0.1.1
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3

{koava-0.1.0 → koava-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "koava"
-version = "0.1.0"
+version = "0.1.1"
 description = "KoalaVault model converter tool for producers"
 readme = "README.md"
 license = {file = "LICENSE"}

{koava-0.1.0 → koava-0.1.1}/src/auth.rs

@@ -210,13 +210,7 @@ impl AuthService {
 
         if let Some(username) = &username_opt {
             // Normalize endpoint to include /api
-            let normalized_endpoint = if self.config.endpoint.ends_with("/api") {
-                self.config.endpoint.clone()
-            } else if self.config.endpoint.ends_with("/") {
-                format!("{}api", self.config.endpoint)
-            } else {
-                format!("{}/api", self.config.endpoint)
-            };
+            let normalized_endpoint = self.config.get_api_endpoint();
 
             // Build HTTP client (no proxy for localhost)
             let mut builder = reqwest::Client::builder()
@@ -281,13 +275,7 @@ impl AuthService {
             .map_err(|e| KoavaError::config(e.to_string()))?;
 
         // Normalize endpoint to include /api
-        let normalized_endpoint = if self.config.endpoint.ends_with("/api") {
-            self.config.endpoint.clone()
-        } else if self.config.endpoint.ends_with("/") {
-            format!("{}api", self.config.endpoint)
-        } else {
-            format!("{}/api", self.config.endpoint)
-        };
+        let normalized_endpoint = self.config.get_api_endpoint();
 
         // Disable proxy for localhost to avoid corporate/system proxy causing 502
         let mut builder = reqwest::Client::builder()

{koava-0.1.0 → koava-0.1.1}/src/cli.rs

@@ -40,6 +40,16 @@ impl CliHandler {
         }
     }
 
+    /// Get the authenticated client and config
+    async fn get_authenticated_client(
+        &self,
+    ) -> Result<(Config, std::sync::Arc<crate::HttpClient>)> {
+        let config = self.load_config().await?;
+        let auth_service = crate::auth::AuthService::new(config.clone());
+        let client = auth_service.get_authenticated_client().await?;
+        Ok((config, client))
+    }
+
     /// Execute a CLI command
     pub async fn execute(&mut self, command: Commands) -> Result<()> {
         match command {
@@ -59,9 +69,7 @@ impl CliHandler {
 
     /// Handle encrypt command
     async fn handle_encrypt(&mut self, args: EncryptArgs) -> Result<()> {
-        let config = self.load_config().await?;
-        let auth_service = crate::auth::AuthService::new(config.clone());
-        let client = auth_service.get_authenticated_client().await?;
+        let (config, client) = self.get_authenticated_client().await?;
         let encrypt_service = EncryptService::new(config);
         encrypt_service.encrypt(&*client, args).await
     }
@@ -75,18 +83,14 @@ impl CliHandler {
 
     /// Handle upload command - upload encrypted model to server
     async fn handle_upload(&mut self, args: UploadArgs) -> Result<()> {
-        let config = self.load_config().await?;
-        let auth_service = crate::auth::AuthService::new(config);
-        let client = auth_service.get_authenticated_client().await?;
+        let (_config, client) = self.get_authenticated_client().await?;
         let service = crate::model::ModelService::new();
         service.upload(client, args).await
     }
 
     /// Handle remove command
     async fn handle_remove(&mut self, args: RemoveArgs) -> Result<()> {
-        let config = self.load_config().await?;
-        let auth_service = crate::auth::AuthService::new(config);
-        let client = auth_service.get_authenticated_client().await?;
+        let (_config, client) = self.get_authenticated_client().await?;
         let service = crate::model::ModelService::new();
         service.remove(client, args).await
     }
@@ -147,27 +151,21 @@ impl CliHandler {
 
     /// Handle list command - list files for a model on server
     async fn handle_list(&mut self, args: ListArgs) -> Result<()> {
-        let config = self.load_config().await?;
-        let auth_service = crate::auth::AuthService::new(config);
-        let client = auth_service.get_authenticated_client().await?;
+        let (_config, client) = self.get_authenticated_client().await?;
         let service = crate::model::ModelService::new();
         service.list(client, args).await
     }
 
     /// Handle create command
     async fn handle_create(&mut self, args: CreateArgs) -> Result<()> {
-        let config = self.load_config().await?;
-        let auth_service = crate::auth::AuthService::new(config);
-        let client = auth_service.get_authenticated_client().await?;
+        let (_config, client) = self.get_authenticated_client().await?;
         let service = crate::model::ModelService::new();
         service.create(client, args).await
     }
 
     /// Handle push command: create -> encrypt -> upload -> hf create repo -> upload to hf -> update model
     async fn handle_push(&mut self, args: crate::PushArgs) -> Result<()> {
-        let config = self.load_config().await?;
-        let auth_service = crate::auth::AuthService::new(config.clone());
-        let client = auth_service.get_authenticated_client().await?;
+        let (config, client) = self.get_authenticated_client().await?;
         let mut service = crate::push::PushService::new(config);
         service.push(client, args).await
     }

{koava-0.1.0 → koava-0.1.1}/src/config.rs

@@ -203,6 +203,18 @@ impl Config {
         crate::security::verify_certificate_pinning(&self.endpoint, &self.server_public_key).await
     }
 
+    /// Get the API base endpoint (ensuring /api suffix and proper scheme)
+    pub fn get_api_endpoint(&self) -> String {
+        let base = self.endpoint_url("");
+        let base = base.trim_end_matches('/');
+
+        if base.ends_with("/api") {
+            base.to_string()
+        } else {
+            format!("{}/api", base)
+        }
+    }
+
     /// Get the full URL for an endpoint
     pub fn endpoint_url(&self, endpoint: &str) -> String {
         let endpoint = endpoint.strip_prefix('/').unwrap_or(endpoint);
@@ -645,4 +657,29 @@ mod tests {
         config.endpoint = "api.test.com".to_string();
         assert_eq!(config.endpoint_url(""), "https://api.test.com/");
     }
+
+    #[test]
+    fn test_get_api_endpoint() {
+        let mut config = Config::default();
+
+        // Case 1: No /api suffix
+        config.endpoint = "https://example.com".to_string();
+        assert_eq!(config.get_api_endpoint(), "https://example.com/api");
+
+        // Case 2: With /api suffix
+        config.endpoint = "https://example.com/api".to_string();
+        assert_eq!(config.get_api_endpoint(), "https://example.com/api");
+
+        // Case 3: With trailing slash
+        config.endpoint = "https://example.com/".to_string();
+        assert_eq!(config.get_api_endpoint(), "https://example.com/api");
+
+        // Case 4: With /api/ suffix
+        config.endpoint = "https://example.com/api/".to_string();
+        assert_eq!(config.get_api_endpoint(), "https://example.com/api");
+
+        // Case 5: Missing scheme (adds https)
+        config.endpoint = "example.com".to_string();
+        assert_eq!(config.get_api_endpoint(), "https://example.com/api");
+    }
 }

{koava-0.1.0 → koava-0.1.1}/src/model.rs

@@ -241,25 +241,24 @@ pub async fn encrypt_safetensors_file(
 /// Extract non-reserved metadata from safetensors file header
 /// This parses the JSON header and filters out reserved fields (starting with "__")
 fn extract_metadata_from_header(file_content: &[u8]) -> Result<Option<HashMap<String, String>>> {
-    const N_LEN: usize = 8;
-
-    // Read header length (first 8 bytes)
-    if file_content.len() < N_LEN {
+    // Read header length
+    if file_content.len() < CryptoUtils::HEADER_LENGTH_SIZE {
         return Ok(None);
     }
 
     let header_len = u64::from_le_bytes(
-        file_content[..N_LEN]
+        file_content[..CryptoUtils::HEADER_LENGTH_SIZE]
             .try_into()
             .map_err(|_| KoavaError::io("Header parsing", "Invalid header length"))?,
     ) as usize;
 
-    if file_content.len() < N_LEN + header_len {
+    if file_content.len() < CryptoUtils::HEADER_LENGTH_SIZE + header_len {
         return Ok(None);
     }
 
     // Parse JSON header
-    let header_bytes = &file_content[N_LEN..N_LEN + header_len];
+    let header_bytes = &file_content
+        [CryptoUtils::HEADER_LENGTH_SIZE..CryptoUtils::HEADER_LENGTH_SIZE + header_len];
     let header_str = std::str::from_utf8(header_bytes)
         .map_err(|e| KoavaError::io("Header parsing", format!("Invalid UTF-8: {}", e)))?;
 
@@ -267,7 +266,7 @@ fn extract_metadata_from_header(file_content: &[u8]) -> Result<Option<HashMap<St
         .map_err(|e| KoavaError::serialization(format!("Invalid JSON in header: {}", e)))?;
 
     // Extract __metadata__ field if present
-    if let Some(metadata_obj) = header_json.get("__metadata__") {
+    if let Some(metadata_obj) = header_json.get(CryptoUtils::METADATA_KEY) {
         if let Some(metadata_map) = metadata_obj.as_object() {
             // Filter out reserved fields (starting with "__")
             let mut filtered_metadata = HashMap::new();

{koava-0.1.0 → koava-0.1.1}/src/upload.rs

@@ -215,7 +215,7 @@ impl<C: ApiClient + ?Sized> UploadService<C> {
                 continue;
             }
 
-            match CryptoUtils::extract_safetensors_header(&file.path) {
+            match CryptoUtils::extract_safetensors_header(&file.path).await {
                 Ok(header_data) => {
                     let file_info = FileInfo {
                         id: None,

{koava-0.1.0 → koava-0.1.1}/src/utils.rs

@@ -3,8 +3,6 @@
 use base64::{engine::general_purpose, Engine};
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
-use std::fs::File;
-use std::io::{BufReader, Read};
 use std::path::Path;
 
 use crate::error::{KoavaError, Result};
@@ -46,6 +44,11 @@ pub struct FileInfo {
 pub struct CryptoUtils;
 
 impl CryptoUtils {
+    pub const HEADER_LENGTH_SIZE: usize = 8;
+    pub const MAX_HEADER_SIZE: usize = 1024 * 1024;
+    pub const METADATA_KEY: &str = "__metadata__";
+    pub const ENCRYPTION_KEY: &str = "__encryption__";
+
     /// Calculate SHA256 hash of a string (used for header hashing)
     pub fn calculate_sha256_hash(data: &str) -> String {
         let mut hasher = Sha256::new();
@@ -60,34 +63,48 @@ impl CryptoUtils {
         hex::encode(hasher.finalize())
     }
 
-    /// Extract header data from a Safetensors file
-    /// This reads the first 8 bytes (header length) + header JSON and encodes as base64
-    pub fn extract_safetensors_header<P: AsRef<Path>>(file_path: P) -> Result<String> {
+    /// Read the safetensors header raw bytes (excluding length prefix).
+    /// This function handles the 8-byte length reading and size validation.
+    pub async fn read_safetensors_header_raw<P: AsRef<Path>>(file_path: P) -> Result<Vec<u8>> {
         let file_path = file_path.as_ref();
-        let mut file = BufReader::new(
-            File::open(file_path)
-                .map_err(|e| KoavaError::io("File open", format!("Failed to open file: {}", e)))?,
-        );
+        let mut file = tokio::fs::File::open(file_path)
+            .await
+            .map_err(|e| KoavaError::io("File open", format!("Failed to open file: {}", e)))?;
 
-        // Read header length (first 8 bytes, little endian)
-        let mut header_len_bytes = [0u8; 8];
-        file.read_exact(&mut header_len_bytes)
-            .map_err(|e| KoavaError::crypto(format!("Failed to read header length: {}", e)))?;
+        let mut header_len_bytes = [0u8; Self::HEADER_LENGTH_SIZE];
+        use tokio::io::AsyncReadExt;
+        file.read_exact(&mut header_len_bytes).await.map_err(|e| {
+            KoavaError::io(
+                "Header read",
+                format!("Failed to read header length: {}", e),
+            )
+        })?;
 
         let header_len = u64::from_le_bytes(header_len_bytes) as usize;
 
-        if header_len > 1024 * 1024 {
-            // 1MB limit for safety
-            return Err(KoavaError::crypto("Header too large"));
+        if header_len > Self::MAX_HEADER_SIZE {
+            return Err(KoavaError::validation(
+                "Header too large (exceeds 1MB limit)",
+            ));
         }
 
-        // Read header JSON
         let mut header_json_bytes = vec![0u8; header_len];
-        file.read_exact(&mut header_json_bytes)
-            .map_err(|e| KoavaError::crypto(format!("Failed to read header JSON: {}", e)))?;
+        file.read_exact(&mut header_json_bytes).await.map_err(|e| {
+            KoavaError::io("Header read", format!("Failed to read header JSON: {}", e))
+        })?;
+
+        Ok(header_json_bytes)
+    }
+
+    /// Extract header data from a Safetensors file
+    /// This reads the first 8 bytes (header length) + header JSON and encodes as base64
+    pub async fn extract_safetensors_header<P: AsRef<Path>>(file_path: P) -> Result<String> {
+        let header_json_bytes = Self::read_safetensors_header_raw(file_path).await?;
+        let header_len = header_json_bytes.len();
+        let header_len_bytes = (header_len as u64).to_le_bytes();
 
         // Combine header length + header JSON
-        let mut header_data = Vec::with_capacity(8 + header_len);
+        let mut header_data = Vec::with_capacity(Self::HEADER_LENGTH_SIZE + header_len);
         header_data.extend_from_slice(&header_len_bytes);
         header_data.extend_from_slice(&header_json_bytes);
 
@@ -126,37 +143,7 @@ impl CryptoUtils {
     /// Detect if a safetensors file is encrypted by checking its header metadata
     /// This function only reads the file header portion, not the entire file
     pub async fn detect_safetensors_encryption<P: AsRef<Path>>(file_path: P) -> Result<bool> {
-        let file_path = file_path.as_ref();
-
-        // Open file and read only the header portion
-        let mut file = tokio::fs::File::open(file_path)
-            .await
-            .map_err(|e| KoavaError::io("File open", format!("Failed to open file: {}", e)))?;
-
-        // Read header length (first 8 bytes, little endian)
-        let mut header_len_bytes = [0u8; 8];
-        use tokio::io::AsyncReadExt;
-        file.read_exact(&mut header_len_bytes).await.map_err(|e| {
-            KoavaError::io(
-                "Header read",
-                format!("Failed to read header length: {}", e),
-            )
-        })?;
-
-        let header_len = u64::from_le_bytes(header_len_bytes) as usize;
-
-        if header_len > 1024 * 1024 {
-            // 1MB limit for safety
-            return Err(KoavaError::validation(
-                "Header too large (exceeds 1MB limit)",
-            ));
-        }
-
-        // Read header JSON
-        let mut header_json_bytes = vec![0u8; header_len];
-        file.read_exact(&mut header_json_bytes).await.map_err(|e| {
-            KoavaError::io("Header read", format!("Failed to read header JSON: {}", e))
-        })?;
+        let header_json_bytes = Self::read_safetensors_header_raw(file_path).await?;
 
         // Parse the header JSON to check for encryption metadata
         let header_json: serde_json::Value =
@@ -165,9 +152,9 @@ impl CryptoUtils {
             })?;
 
         // Check if the file contains encryption metadata
-        if let Some(metadata) = header_json.get("__metadata__") {
+        if let Some(metadata) = header_json.get(Self::METADATA_KEY) {
             if let Some(metadata_obj) = metadata.as_object() {
-                if metadata_obj.contains_key("__encryption__") {
+                if metadata_obj.contains_key(Self::ENCRYPTION_KEY) {
                     return Ok(true);
                 }
             }
@@ -234,12 +221,14 @@ mod tests {
             assert!(result.is_err());
         }
 
-        #[test]
-        fn test_extract_safetensors_header() {
+        #[tokio::test]
+        async fn test_extract_safetensors_header() {
             let temp_dir = create_temp_dir();
             let file_path = create_mock_safetensors_file(&temp_dir, "model.safetensors", false);
 
-            let header_b64 = CryptoUtils::extract_safetensors_header(&file_path).unwrap();
+            let header_b64 = CryptoUtils::extract_safetensors_header(&file_path)
+                .await
+                .unwrap();
 
             // Verify it's valid base64
             let decoded = CryptoUtils::decode_base64(&header_b64).unwrap();
@@ -248,9 +237,10 @@ mod tests {
             assert_eq!(decoded.len() >= 8, true);
         }
 
-        #[test]
-        fn test_extract_safetensors_header_nonexistent_file() {
-            let result = CryptoUtils::extract_safetensors_header("/nonexistent/file.safetensors");
+        #[tokio::test]
+        async fn test_extract_safetensors_header_nonexistent_file() {
+            let result =
+                CryptoUtils::extract_safetensors_header("/nonexistent/file.safetensors").await;
             assert!(result.is_err());
         }