python-package-folder 4.1.3__py3-none-any.whl → 4.3.0__py3-none-any.whl

python_package_folder/_hatch_build.py

@@ -18,13 +18,29 @@ class CustomBuildHook(BuildHookInterface):
 
     def initialize(self, version: str, build_data: dict[str, Any]) -> None:
         """Initialize the build hook and add scripts directory files."""
-        # Get the source directory for the package
-        source_dir = Path(self.root) / "src" / "python_package_folder"
-        scripts_dir = source_dir / "scripts"
-
         # Debug: Print to stderr so it shows in build output
         print(f"[DEBUG] Build hook called. Root: {self.root}", file=sys.stderr)
-        print(f"[DEBUG] Scripts dir exists: {scripts_dir.exists()}", file=sys.stderr)
+        
+        # Try multiple possible locations for the scripts directory
+        # 1. Source layout: src/python_package_folder/scripts
+        # 2. Sdist layout: python_package_folder/scripts (after extraction)
+        # 3. Alternative sdist layout: scripts/ (if extracted differently)
+        possible_scripts_dirs = [
+            Path(self.root) / "src" / "python_package_folder" / "scripts",
+            Path(self.root) / "python_package_folder" / "scripts",
+            Path(self.root) / "scripts",
+        ]
+        
+        scripts_dir = None
+        for possible_dir in possible_scripts_dirs:
+            if possible_dir.exists() and possible_dir.is_dir():
+                scripts_dir = possible_dir
+                print(f"[DEBUG] Found scripts dir at: {scripts_dir}", file=sys.stderr)
+                break
+        
+        if scripts_dir is None:
+            print(f"[DEBUG] Scripts directory not found. Tried: {[str(d) for d in possible_scripts_dirs]}", file=sys.stderr)
+            return
 
         # If scripts directory exists, include all files from it
         if scripts_dir.exists() and scripts_dir.is_dir():
@@ -32,9 +48,25 @@ class CustomBuildHook(BuildHookInterface):
             # This ensures they're included in the wheel at the correct location
             for script_file in scripts_dir.iterdir():
                 if script_file.is_file():
-                    # Calculate relative paths
-                    source_path = script_file.relative_to(self.root)
-                    # Target path inside the wheel package
+                    # Calculate relative paths from project root
+                    try:
+                        source_path = script_file.relative_to(self.root)
+                    except ValueError:
+                        # If relative_to fails, try to construct path manually
+                        # This can happen with sdist layouts
+                        if "python_package_folder" in str(script_file):
+                            # Extract the part after python_package_folder
+                            parts = script_file.parts
+                            try:
+                                idx = parts.index("python_package_folder")
+                                source_path = Path(*parts[idx:])
+                            except (ValueError, IndexError):
+                                # Fallback: use the filename
+                                source_path = Path("python_package_folder") / "scripts" / script_file.name
+                        else:
+                            source_path = Path("python_package_folder") / "scripts" / script_file.name
+                    
+                    # Target path inside the wheel package (always the same)
                     target_path = f"python_package_folder/scripts/{script_file.name}"
 
                     print(f"[DEBUG] Adding {source_path} -> {target_path}", file=sys.stderr)
@@ -46,8 +78,6 @@ class CustomBuildHook(BuildHookInterface):
                     build_data["force_include"][str(source_path)] = target_path
             
             print(f"[DEBUG] force_include now has {len(build_data.get('force_include', {}))} entries", file=sys.stderr)
-        else:
-            print(f"[DEBUG] Scripts directory not found at {scripts_dir}", file=sys.stderr)
 
 
 # Export the hook class (hatchling might need this)

python_package_folder/scripts/get-next-version.cjs

@@ -0,0 +1,553 @@
+#!/usr/bin/env node
+/**
+ * Get next version using semantic-release.
+ * 
+ * This script runs semantic-release in dry-run mode to determine the next version
+ * for a package. It supports both subfolder builds (per-package tags) and main
+ * package builds (repo-level tags).
+ * 
+ * Usage:
+ *   node scripts/get-next-version.cjs <project_root> [subfolder_path] [package_name] [repository] [repository_url]
+ * 
+ * Args:
+ *   - project_root: Root directory of the project (absolute or relative path)
+ *   - subfolder_path: Optional. Path to subfolder relative to project_root (for Workflow 1)
+ *   - package_name: Optional. Package name for subfolder builds (for per-package tags)
+ *   - repository: Optional. Target repository ('pypi', 'testpypi', or 'azure')
+ *   - repository_url: Optional. Repository URL (required for Azure Artifacts)
+ * 
+ * Output:
+ *   - Version string (e.g., "1.2.3") if a release is determined
+ *   - "none" if semantic-release determines no release is needed
+ *   - Exits with non-zero code on error
+ */
+
+const path = require('path');
+const fs = require('fs');
+const https = require('https');
+const http = require('http');
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+if (args.length < 1) {
+  console.error('Error: project_root is required');
+  console.error('Usage: node get-next-version.cjs <project_root> [subfolder_path] [package_name] [repository] [repository_url]');
+  process.exit(1);
+}
+
+const projectRoot = path.resolve(args[0]);
+const subfolderPath = args[1] && args[1] !== 'null' && args[1] !== '' ? args[1] : null;
+const packageName = args[2] && args[2] !== 'null' && args[2] !== '' ? args[2] : null;
+const repository = args[3] && args[3] !== 'null' && args[3] !== '' ? args[3] : null;
+const repositoryUrl = args[4] && args[4] !== 'null' && args[4] !== '' ? args[4] : null;
+
+// Validate argument combination
+// - For subfolder builds: both subfolder_path and package_name are required
+// - For main package builds: package_name can be provided alone (for registry queries)
+if (subfolderPath !== null && packageName === null) {
+  console.error('Error: package_name is required when subfolder_path is provided.');
+  console.error('Usage: node get-next-version.cjs <project_root> [subfolder_path] [package_name] [repository] [repository_url]');
+  process.exit(1);
+}
+// Note: package_name can be provided without subfolder_path for main package registry queries
+
+// Check if project root exists
+if (!fs.existsSync(projectRoot)) {
+  console.error(`Error: Project root does not exist: ${projectRoot}`);
+  process.exit(1);
+}
+
+// Determine if this is a subfolder build
+// A subfolder build requires both subfolder_path and package_name
+// package_name alone (without subfolder_path) indicates a main package build with registry query
+const isSubfolderBuild = subfolderPath !== null && packageName !== null;
+const workingDir = isSubfolderBuild 
+  ? path.resolve(projectRoot, subfolderPath)
+  : projectRoot;
+
+// Check if working directory exists
+if (!fs.existsSync(workingDir)) {
+  console.error(`Error: Working directory does not exist: ${workingDir}`);
+  process.exit(1);
+}
+
+// For subfolder builds, ensure package.json exists with correct name
+let tempPackageJson = null;
+let backupCreatedByScript = false;
+let fileCreatedByScript = false;
+let originalPackageJsonContent = null; // Track original content for restoration
+if (isSubfolderBuild) {
+  const packageJsonPath = path.join(workingDir, 'package.json');
+  const hadPackageJson = fs.existsSync(packageJsonPath);
+  
+  if (!hadPackageJson) {
+    // Create temporary package.json for semantic-release-commit-filter
+    const packageJsonContent = JSON.stringify({
+      name: packageName,
+      version: '0.0.0'
+    }, null, 2);
+    fs.writeFileSync(packageJsonPath, packageJsonContent, 'utf8');
+    tempPackageJson = packageJsonPath;
+    fileCreatedByScript = true;
+  } else {
+    // Read existing package.json and ensure name matches
+    try {
+      const existing = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      const backup = packageJsonPath + '.backup';
+      const backupExists = fs.existsSync(backup);
+      
+      // Store original content before any modifications
+      originalPackageJsonContent = fs.readFileSync(packageJsonPath, 'utf8');
+      
+      if (existing.name !== packageName) {
+        // Need to modify the name
+        // Check if backup is stale (from a previous crashed run)
+        // A backup is stale if it contains the same name we're trying to set
+        let isStaleBackup = false;
+        if (backupExists) {
+          try {
+            const backupContent = JSON.parse(fs.readFileSync(backup, 'utf8'));
+            // If backup has the name we're trying to set, it's stale from a previous run
+            if (backupContent.name === packageName) {
+              isStaleBackup = true;
+            }
+          } catch (e) {
+            // If we can't read the backup, treat it as potentially stale
+            isStaleBackup = true;
+          }
+        }
+        
+        // If backup is stale, restore from it first, then create a fresh backup
+        if (isStaleBackup) {
+          try {
+            fs.copyFileSync(backup, packageJsonPath);
+            // Re-read after restoration and update original content
+            originalPackageJsonContent = fs.readFileSync(packageJsonPath, 'utf8');
+            const restored = JSON.parse(originalPackageJsonContent);
+            // Now create a fresh backup of the restored original
+            fs.copyFileSync(packageJsonPath, backup);
+            backupCreatedByScript = true;
+            // Update the restored content with the new name
+            restored.name = packageName;
+            fs.writeFileSync(packageJsonPath, JSON.stringify(restored, null, 2), 'utf8');
+          } catch (e) {
+            // If restoration fails, create a new backup of current state
+            fs.copyFileSync(packageJsonPath, backup);
+            backupCreatedByScript = true;
+            existing.name = packageName;
+            fs.writeFileSync(packageJsonPath, JSON.stringify(existing, null, 2), 'utf8');
+          }
+        } else {
+          // Backup doesn't exist or is valid (preserves user's original)
+          // If backup exists, it's user's backup - we'll restore from originalPackageJsonContent
+          // If backup doesn't exist, create one
+          if (!backupExists) {
+            fs.copyFileSync(packageJsonPath, backup);
+            backupCreatedByScript = true;
+          }
+          // Modify the file
+          existing.name = packageName;
+          fs.writeFileSync(packageJsonPath, JSON.stringify(existing, null, 2), 'utf8');
+        }
+        tempPackageJson = packageJsonPath;
+      } else if (backupExists) {
+        // Name already matches, but check if backup is stale
+        // If backup has the same name, it's from a previous crashed run
+        try {
+          const backupContent = JSON.parse(fs.readFileSync(backup, 'utf8'));
+          if (backupContent.name === packageName) {
+            // Stale backup from previous run - restore it
+            fs.copyFileSync(backup, packageJsonPath);
+            // Update original content after restoration
+            originalPackageJsonContent = fs.readFileSync(packageJsonPath, 'utf8');
+            // Remove stale backup since we've restored
+            fs.unlinkSync(backup);
+            // Re-check if we need to modify after restoration
+            const restored = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            if (restored.name !== packageName) {
+              // After restoration, name doesn't match - need to modify
+              fs.copyFileSync(packageJsonPath, backup);
+              backupCreatedByScript = true;
+              restored.name = packageName;
+              fs.writeFileSync(packageJsonPath, JSON.stringify(restored, null, 2), 'utf8');
+              tempPackageJson = packageJsonPath;
+            }
+          }
+        } catch (e) {
+          // If we can't read backup, leave it as-is (might be user's backup)
+        }
+      }
+    } catch (e) {
+      console.error(`Error reading package.json: ${e.message}`);
+      process.exit(1);
+    }
+  }
+}
+
+/**
+ * Query PyPI or TestPyPI JSON API for the latest version of a package.
+ * @param {string} packageName - Package name to query
+ * @param {string} registry - 'pypi' or 'testpypi'
+ * @returns {Promise<string|null>} Latest version string or null if not found
+ */
+async function queryPyPIVersion(packageName, registry) {
+  const baseUrl = registry === 'testpypi' 
+    ? 'https://test.pypi.org'
+    : 'https://pypi.org';
+  const url = `${baseUrl}/pypi/${packageName}/json`;
+  
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      let data = '';
+      
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+      
+      res.on('end', () => {
+        if (res.statusCode === 404) {
+          // Package doesn't exist yet (first release)
+          resolve(null);
+        } else if (res.statusCode === 200) {
+          try {
+            const json = JSON.parse(data);
+            // Get latest version from info.version or releases
+            const version = json.info?.version || Object.keys(json.releases || {}).pop() || null;
+            resolve(version);
+          } catch (e) {
+            reject(new Error(`Failed to parse PyPI response: ${e.message}`));
+          }
+        } else {
+          reject(new Error(`PyPI API returned status ${res.statusCode}`));
+        }
+      });
+    }).on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Query Azure Artifacts for the latest version of a package.
+ * Azure Artifacts uses a simple index format (HTML) which is more complex to parse.
+ * For now, we'll attempt to query but fall back gracefully if it fails.
+ * @param {string} packageName - Package name to query
+ * @param {string} repositoryUrl - Azure Artifacts repository URL
+ * @returns {Promise<string|null>} Latest version string or null if not found/unsupported
+ */
+async function queryAzureArtifactsVersion(packageName, repositoryUrl) {
+  // Convert upload URL to simple index URL
+  // Upload: https://pkgs.dev.azure.com/ORG/PROJECT/_packaging/FEED/pypi/upload
+  // Simple: https://pkgs.dev.azure.com/ORG/PROJECT/_packaging/FEED/pypi/simple/{package}/
+  let simpleIndexUrl;
+  try {
+    const url = new URL(repositoryUrl);
+    if (url.pathname.endsWith('/upload')) {
+      simpleIndexUrl = repositoryUrl.replace('/upload', `/simple/${packageName}/`);
+    } else {
+      // Try to construct from common patterns
+      simpleIndexUrl = repositoryUrl.replace(/\/upload$/, `/simple/${packageName}/`);
+    }
+  } catch (e) {
+    // Invalid URL format, return null to fall back to git tags
+    return null;
+  }
+  
+  return new Promise((resolve) => {
+    // Azure Artifacts may require authentication and returns HTML
+    // For now, we'll attempt the request but gracefully fall back if it fails
+    // This is a limitation - Azure Artifacts API is more complex than PyPI
+    const url = new URL(simpleIndexUrl);
+    const client = url.protocol === 'https:' ? https : http;
+    
+    const req = client.get(simpleIndexUrl, (res) => {
+      // Azure Artifacts simple index returns HTML, not JSON
+      // Parsing HTML is complex and may require authentication
+      // For now, we'll return null to fall back to git tags
+      // This can be enhanced later with proper HTML parsing or API endpoint discovery
+      resolve(null);
+    });
+    
+    req.on('error', () => {
+      // Network error or authentication required - fall back to git tags
+      resolve(null);
+    });
+    
+    req.setTimeout(5000, () => {
+      req.destroy();
+      resolve(null);
+    });
+  });
+}
+
+/**
+ * Query the package registry for the latest published version.
+ * @param {string} packageName - Package name to query
+ * @param {string|null} repository - Repository type ('pypi', 'testpypi', 'azure', or null)
+ * @param {string|null} repositoryUrl - Repository URL (for Azure)
+ * @returns {Promise<string|null>} Latest version or null if not found/unsupported
+ */
+async function queryRegistryVersion(packageName, repository, repositoryUrl) {
+  if (!repository || !packageName) {
+    return null;
+  }
+  
+  try {
+    if (repository === 'pypi' || repository === 'testpypi') {
+      return await queryPyPIVersion(packageName, repository);
+    } else if (repository === 'azure') {
+      if (!repositoryUrl) {
+        return null;
+      }
+      return await queryAzureArtifactsVersion(packageName, repositoryUrl);
+    }
+  } catch (error) {
+    // Log error but don't fail - fall back to git tags
+    console.error(`Warning: Failed to query ${repository} for latest version: ${error.message}`);
+    console.error('Falling back to git tags for version detection.');
+  }
+  
+  return null;
+}
+
+// Main execution
+(async () => {
+  try {
+    // Try to require semantic-release
+    // First try resolving from project root (for devDependencies), then fall back to global
+    let semanticRelease;
+  try {
+    const semanticReleasePath = require.resolve('semantic-release', { paths: [projectRoot] });
+    semanticRelease = require(semanticReleasePath);
+  } catch (resolveError) {
+    try {
+      semanticRelease = require('semantic-release');
+    } catch (e) {
+      console.error('Error: semantic-release is not installed.');
+      console.error('Please install it with: npm install -g semantic-release');
+      console.error('Or install it as a devDependency: npm install --save-dev semantic-release');
+      if (isSubfolderBuild) {
+        console.error('For subfolder builds, also install: npm install -g semantic-release-commit-filter');
+        console.error('Or as devDependency: npm install --save-dev semantic-release-commit-filter');
+      }
+      process.exit(1);
+    }
+  }
+
+  // For subfolder builds, require semantic-release-commit-filter
+  // (required only to verify it's installed; the plugin is used via options.plugins)
+  // First try resolving from project root (for devDependencies), then fall back to global
+  if (isSubfolderBuild) {
+    try {
+      const commitFilterPath = require.resolve('semantic-release-commit-filter', { paths: [projectRoot] });
+      require(commitFilterPath);
+    } catch (resolveError) {
+      try {
+        require('semantic-release-commit-filter');
+      } catch (e) {
+        console.error('Error: semantic-release-commit-filter is not installed.');
+        console.error('Please install it with: npm install -g semantic-release-commit-filter');
+        console.error('Or install it as a devDependency: npm install --save-dev semantic-release-commit-filter');
+        process.exit(1);
+      }
+    }
+  }
+
+  // Query registry for latest version if repository info is provided
+  let registryVersion = null;
+  if (repository && packageName) {
+    try {
+      registryVersion = await queryRegistryVersion(packageName, repository, repositoryUrl);
+      if (registryVersion) {
+        console.error(`Found latest version on ${repository}: ${registryVersion}`);
+      } else {
+        console.error(`Package not found on ${repository} or query failed, using git tags as fallback`);
+      }
+    } catch (error) {
+      console.error(`Warning: Registry query failed: ${error.message}`);
+      console.error('Falling back to git tags for version detection.');
+    }
+  }
+
+  // Configure semantic-release options
+  const options = {
+    dryRun: true,
+    ci: false,
+  };
+  
+  // If we have a registry version, we can use it to set lastRelease in semantic-release context
+  // This ensures semantic-release uses the registry version as baseline instead of git tags
+  if (registryVersion) {
+    // Set lastRelease in options to use registry version as baseline
+    // This tells semantic-release to analyze commits since this version
+    options.lastRelease = {
+      version: registryVersion,
+      gitTag: isSubfolderBuild 
+        ? `${packageName}-v${registryVersion}`
+        : `v${registryVersion}`,
+      gitHead: null, // We don't know the commit, but semantic-release will find it
+    };
+  }
+
+  // For subfolder builds, configure commit filter and per-package tags
+  if (isSubfolderBuild) {
+    // Get relative path from project root to subfolder for commit filtering
+    const relPath = path.relative(projectRoot, workingDir).replace(/\\/g, '/');
+    
+    options.plugins = [
+      ['@semantic-release/commit-analyzer', {
+        preset: 'angular',
+      }],
+      ['semantic-release-commit-filter', {
+        cwd: workingDir,
+        path: relPath,
+      }],
+      ['@semantic-release/release-notes-generator', {
+        preset: 'angular',
+      }],
+    ];
+    
+    // Use per-package tag format: {package-name}-v{version}
+    options.tagFormat = `${packageName}-v\${version}`;
+  } else {
+    // Main package: use default tag format v{version}
+    options.plugins = [
+      ['@semantic-release/commit-analyzer', {
+        preset: 'angular',
+      }],
+      ['@semantic-release/release-notes-generator', {
+        preset: 'angular',
+      }],
+    ];
+  }
+
+  // Run semantic-release (returns a promise)
+  semanticRelease(options, {
+    cwd: workingDir,
+    env: {
+      ...process.env,
+      // Ensure git commands run from project root for subfolder builds
+      GIT_DIR: path.join(projectRoot, '.git'),
+      GIT_WORK_TREE: projectRoot,
+    },
+  }).then((result) => {
+    // Clean up temporary package.json if we created or modified it
+    if (tempPackageJson && fs.existsSync(tempPackageJson)) {
+      const backup = tempPackageJson + '.backup';
+      if (backupCreatedByScript && fs.existsSync(backup)) {
+        // Restore original (only if we created the backup)
+        fs.copyFileSync(backup, tempPackageJson);
+        fs.unlinkSync(backup);
+      } else if (fileCreatedByScript) {
+        // Remove temporary file (only if we created it, not if it existed before)
+        fs.unlinkSync(tempPackageJson);
+      } else if (originalPackageJsonContent !== null) {
+        // We modified an existing file but didn't create a backup (user's backup exists)
+        // Restore from the original content we stored, but don't delete user's backup
+        fs.writeFileSync(tempPackageJson, originalPackageJsonContent, 'utf8');
+      }
+    }
+
+    // Output result
+    if (result && result.nextRelease && result.nextRelease.version) {
+      console.log(result.nextRelease.version);
+      process.exit(0);
+    } else {
+      console.log('none');
+      process.exit(0);
+    }
+  }).catch((error) => {
+    // Clean up temporary package.json on error
+    if (tempPackageJson && fs.existsSync(tempPackageJson)) {
+      const backup = tempPackageJson + '.backup';
+      if (backupCreatedByScript && fs.existsSync(backup)) {
+        try {
+          // Restore original (only if we created the backup)
+          fs.copyFileSync(backup, tempPackageJson);
+          fs.unlinkSync(backup);
+        } catch (e) {
+          // Ignore cleanup errors
+        }
+      } else if (fileCreatedByScript) {
+        try {
+          // Remove temporary file (only if we created it, not if it existed before)
+          fs.unlinkSync(tempPackageJson);
+        } catch (e) {
+          // Ignore cleanup errors
+        }
+      } else if (originalPackageJsonContent !== null) {
+        // We modified an existing file but didn't create a backup (user's backup exists)
+        // Restore from the original content we stored, but don't delete user's backup
+        try {
+          fs.writeFileSync(tempPackageJson, originalPackageJsonContent, 'utf8');
+        } catch (e) {
+          // Ignore cleanup errors
+        }
+      }
+    }
+
+    // Check if it's a "no release" case (common, not an error)
+    if (error.message && (
+      error.message.includes('no release') ||
+      error.message.includes('No release') ||
+      error.code === 'ENOCHANGE'
+    )) {
+      console.log('none');
+      process.exit(0);
+    }
+
+    // Other errors
+    console.error(`Error running semantic-release: ${error.message}`);
+    if (error.stack) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  });
+  } catch (error) {
+    // Clean up temporary package.json on error
+    if (tempPackageJson && fs.existsSync(tempPackageJson)) {
+      const backup = tempPackageJson + '.backup';
+      if (backupCreatedByScript && fs.existsSync(backup)) {
+        try {
+          // Restore original (only if we created the backup)
+          fs.copyFileSync(backup, tempPackageJson);
+          fs.unlinkSync(backup);
+        } catch (e) {
+          // Ignore cleanup errors
+        }
+      } else if (fileCreatedByScript) {
+        try {
+          // Remove temporary file (only if we created it, not if it existed before)
+          fs.unlinkSync(tempPackageJson);
+        } catch (e) {
+          // Ignore cleanup errors
+        }
+      } else if (originalPackageJsonContent !== null) {
+        // We modified an existing file but didn't create a backup (user's backup exists)
+        // Restore from the original content we stored, but don't delete user's backup
+        try {
+          fs.writeFileSync(tempPackageJson, originalPackageJsonContent, 'utf8');
+        } catch (e) {
+          // Ignore cleanup errors
+        }
+      }
+    }
+
+    // Check if it's a "no release" case (common, not an error)
+    if (error.message && (
+      error.message.includes('no release') ||
+      error.message.includes('No release') ||
+      error.code === 'ENOCHANGE'
+    )) {
+      console.log('none');
+      process.exit(0);
+    }
+
+    // Other errors
+    console.error(`Error: ${error.message}`);
+    if (error.stack) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+})();

{python_package_folder-4.1.3.dist-info → python_package_folder-4.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 4.1.3
+Version: 4.3.0
 Summary: Python package to automatically package and build a folder, fetching all relevant dependencies.
 Project-URL: Repository, https://github.com/alelom/python-package-folder
 Author-email: Alessio Lombardi <work@alelom.com>

{python_package_folder-4.1.3.dist-info → python_package_folder-4.3.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 python_package_folder/__init__.py,sha256=DQt-uldOEKfh0MUqCvKdeNKOnpuOvpb7blYvXMyO9Wc,719
 python_package_folder/__main__.py,sha256=a-__-VLhYw-J7S7CsHdhtEvQr3RiAZxiYDvKhKTgMX4,291
-python_package_folder/_hatch_build.py,sha256=03UCz4RSGaLFPpksgZultQ2lskfgMCI-t9gg6rXKj_A,2500
+python_package_folder/_hatch_build.py,sha256=Y50LAM-Jn6f_2M48UZRu-ZIWMY0_nsV8XQyqlRUKoqY,4146
 python_package_folder/analyzer.py,sha256=cmTNUDCWBIh3XZ_mShlQVG1P9NN_oe3FUBTirVtYfTQ,16709
 python_package_folder/finder.py,sha256=RPidZ7LKCFuQ_KgCFIZdHWPXsZIDor3M4C0hKeYW7EI,11799
 python_package_folder/manager.py,sha256=Z9RPg0ZQ7jZhmEXfCzX9OrD_oiA5p2Pnm5Y9tgW3ObQ,55970
@@ -11,8 +11,9 @@ python_package_folder/subfolder_build.py,sha256=oH_KKLJIMByUZCl8y3AyohUO6Om0OvsI
 python_package_folder/types.py,sha256=3yeSRR5p_3PDKEAaehW_RJ7NwJHexOIeA08bGaT1iSY,2368
 python_package_folder/utils.py,sha256=lIkWsFKeAYAJ9TDUM99T4pUBHJVbUvCdUgkWQN-LUho,3111
 python_package_folder/version.py,sha256=kIDP6S9trEfs9gj7lBYGxrWm4RPssRla24UtlO9Jkh4,9111
-python_package_folder-4.1.3.dist-info/METADATA,sha256=5B6fZHMnTazvMxVnV6O10Mr6IU_6MY7nSrqJmqj5yCs,37517
-python_package_folder-4.1.3.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-python_package_folder-4.1.3.dist-info/entry_points.txt,sha256=ttu4wAhoYSHGhWQNercLz9IVTTpXxhVlRA9vSTvaLe0,91
-python_package_folder-4.1.3.dist-info/licenses/LICENSE,sha256=vNgRJh8YiecqZoZld7TtwPI5I72HIymKD9g32fiJjCE,1073
-python_package_folder-4.1.3.dist-info/RECORD,,
+python_package_folder/scripts/get-next-version.cjs,sha256=5gImk8Yyg0_TZ9ZtL6hXx8lSRT4Dn_sdkDl6mynlqTs,21535
+python_package_folder-4.3.0.dist-info/METADATA,sha256=5SxWRMB_PR-_s3P9JaoIQmwE9Eg5srFAEwoesDziop0,37517
+python_package_folder-4.3.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_package_folder-4.3.0.dist-info/entry_points.txt,sha256=ttu4wAhoYSHGhWQNercLz9IVTTpXxhVlRA9vSTvaLe0,91
+python_package_folder-4.3.0.dist-info/licenses/LICENSE,sha256=vNgRJh8YiecqZoZld7TtwPI5I72HIymKD9g32fiJjCE,1073
+python_package_folder-4.3.0.dist-info/RECORD,,