Struct ImportHelper 

pub struct ImportHelper { /* private fields */ }

Main helper for managing Python imports across the codebase

Implementations

impl ImportHelper

pub fn new() -> Self

Create a new import helper instance

pub fn with_package_name(package_name: String) -> Self

Create a new import helper instance with package name for local import detection

pub fn with_formatting_config(config: FormattingConfig) -> Self

Create a new import helper with custom formatting configuration

pub fn with_package_and_config( package_name: String, config: FormattingConfig, ) -> Self

Create a new import helper with package name and custom formatting

pub fn formatting_config(&self) -> &FormattingConfig

Get the current formatting configuration

pub fn set_formatting_config(&mut self, config: FormattingConfig)

Set a new formatting configuration

pub fn registry(&self) -> &PackageRegistry

Get immutable reference to the package registry

Examples

use py_import_helper::ImportHelper;

let helper = ImportHelper::new();
assert!(helper.registry().is_stdlib("typing"));

pub fn registry_mut(&mut self) -> &mut PackageRegistry

Get mutable reference to the package registry

Use this to customize which packages are recognized as stdlib or third-party before generating imports.

Examples

use py_import_helper::ImportHelper;

let mut helper = ImportHelper::new();
helper.registry_mut()
    .add_stdlib_package("my_custom_stdlib")
    .add_third_party_package("my_company_lib");

helper.add_import_string("import my_custom_stdlib");
let (_future, stdlib, _third, _local) = helper.get_categorized();
assert!(stdlib.iter().any(|s| s.contains("my_custom_stdlib")));

pub fn clear_cache(&mut self) -> &mut Self

Clear the categorization cache

Call this after modifying the registry to ensure changes take effect.

Examples

use py_import_helper::ImportHelper;

let mut helper = ImportHelper::new();
helper.add_import_string("import mypackage");
helper.registry_mut().add_stdlib_package("mypackage");
helper.clear_cache();  // Force re-categorization

pub fn add_local_package_prefix( &mut self, prefix: impl Into<String>, ) -> &mut Self

Add a custom local package prefix to the recognition list

pub fn add_local_package_prefixes( &mut self, prefixes: &[impl AsRef<str>], ) -> &mut Self

Add multiple local package prefixes at once

pub fn add_import(&mut self, spec: &ImportSpec)

Add an import using structured ImportSpec

pub fn add_import_string(&mut self, import_statement: &str)

Convenience method to add import from string (for backward compatibility)

pub fn add_from_import(&mut self, package: &str, items: &[&str])

Add a from import statement programmatically Example: add_from_import("typing", &["Any", "Optional"])

pub fn add_from_import_multiline(&mut self, package: &str, items: &[&str])

Add a multiline from import statement programmatically

pub fn add_type_checking_from_import(&mut self, package: &str, items: &[&str])

Add a from import statement to TYPE_CHECKING block programmatically Example: add_type_checking_from_import("httpx", &["Client", "Response"])

pub fn add_direct_import(&mut self, module: &str)

Add a direct import statement programmatically Example: add_direct_import("json“)

pub fn add_type_checking_direct_import(&mut self, module: &str)

Add a direct import statement to TYPE_CHECKING block programmatically Example: add_type_checking_direct_import("httpx“)

pub fn add_type_checking_import(&mut self, import_statement: &str)

Add an import statement to the TYPE_CHECKING block

pub fn get_all_categorized(&self) -> AllCategorizedImports

Generate all imports (regular + TYPE_CHECKING) for templates Returns a tuple with 8 vectors: (future, stdlib, third_party, local, tc_future, tc_stdlib, tc_third_party, tc_local)

pub fn get_type_checking_categorized(&self) -> CategorizedImports

Generate categorized TYPE_CHECKING imports for templates Returns (future_imports, stdlib_imports, third_party_imports, local_imports) Get TYPE_CHECKING imports categorized by type

Returns a tuple of (future_imports, stdlib_imports, third_party_imports, local_imports) for imports that should go in the TYPE_CHECKING block.

pub fn get_type_checking_categorized_impl(&self) -> CategorizedImports

pub fn get_categorized(&self) -> CategorizedImports

Get the collected imports as categorized tuples Returns (future_imports, stdlib_imports, third_party_imports, local_imports)

pub fn clear(&mut self) -> &mut Self

Clear all registered imports while preserving configuration

This method clears both regular and TYPE_CHECKING imports, making the helper ready to collect new imports. Configuration like formatting settings and local package prefixes are preserved.

This is useful when reusing the same helper for multiple files.

Examples

use py_import_helper::ImportHelper;

let mut helper = ImportHelper::with_package_name("mypackage".to_string());
helper.add_import_string("from typing import Any");
assert!(!helper.is_empty());

helper.clear();
assert!(helper.is_empty());
assert_eq!(helper.count(), 0);

pub fn reset(&mut self) -> &mut Self

Reset the import helper to a native state without any configuration

This method resets the helper to the same state as ImportHelper::new(), clearing all imports, local package prefixes, and resetting formatting configuration to defaults. The package name is also cleared.

This is useful when you need a completely fresh helper instance without creating a new one.

Examples

use py_import_helper::ImportHelper;

let mut helper = ImportHelper::with_package_name("mypackage".to_string());
helper.add_local_package_prefix("other_package");
helper.add_import_string("from typing import Any");

// Reset to native state
helper.reset();

assert!(helper.is_empty());
assert_eq!(helper.count(), 0);
// Local package prefixes and package name are cleared

pub fn is_empty(&self) -> bool

Check if any imports have been collected (excluding TYPE_CHECKING imports)

pub fn is_type_checking_empty(&self) -> bool

Check if any TYPE_CHECKING imports have been collected

pub fn count(&self) -> usize

Count total number of import statements collected (excluding TYPE_CHECKING imports)

pub fn count_type_checking(&self) -> usize

Count total number of TYPE_CHECKING import statements collected

pub fn get_formatted(&self) -> Vec<String>

Generate sorted and formatted import statements

pub fn clone_config(&self) -> Self

Clone configuration without imports (useful for creating multiple helpers with same config)

impl ImportHelper

Convenience functions for common import operations

pub fn create_model_imports(&mut self, required_types: &[String])

Create imports for a model file with required type imports

Trait Implementations

impl Debug for ImportHelper

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ImportHelper

fn default() -> Self

Returns the “default value” for a type.