kedro Logo
0.18.14

Learn about Kedro

  • Introduction to Kedro
    • Learn how to use Kedro
      • Assumptions
  • First steps
    • Set up Kedro
      • Installation prerequisites
      • Create a virtual environment for your Kedro project
        • How to create a new virtual environment using conda
        • How to create a new virtual environment without using conda
      • How to install Kedro using pip
      • How to verify your Kedro installation
      • How to upgrade Kedro
      • How to install a development version of Kedro
      • Summary
    • Create a new Kedro project
      • Summary
      • Create a new empty project
      • Create a new project from a configuration file
      • Create a new project containing example code
      • Run the project
      • Visualise a Kedro project
      • Where next?
      • More information about the pandas-iris example project
        • Background information
        • Iris example: visualisation
    • Kedro concepts
      • Summary
      • Node
      • Pipeline
      • Data Catalog
      • Kedro project directory structure
        • conf
        • data
        • src

Tutorial and basic Kedro usage

  • Next steps: Tutorial
    • Set up the spaceflights project
      • Create a new project
      • Install project dependencies
        • Install the dependencies
      • Optional: logging and configuration
        • Configuration best practice to avoid leaking confidential data
    • Set up the data
      • Project datasets
      • Dataset registration
        • Test that Kedro can load the data
      • Further information
        • Custom data
        • Supported data locations
    • Create a data processing pipeline
      • Introduction
      • Data preprocessing node functions
      • The data processing pipeline
      • Test the example
      • Preprocessed data registration
      • Create a table for model input
      • Model input table registration
      • Test the example again
      • Visualise the project
      • Checkpoint
    • Create a data science pipeline
      • Data science nodes
      • Input parameter configuration
      • Model registration
      • Data science pipeline
      • Test the pipelines
        • Slice a pipeline
      • Modular pipelines
        • Optional: Extend the project with namespacing and a modular pipeline
        • How it works: the modular pipeline() wrapper
      • Optional: Kedro runners
    • Package an entire Kedro project
      • Add documentation to a Kedro project
        • Set up the Sphinx project files
        • Build HTML documentation
        • Documentation from docstrings
      • Package a Kedro project
        • Run a packaged project
        • Docker, Airflow and other deployment targets
    • Spaceflights tutorial FAQs
      • How do I resolve these common errors?
        • Dataset errors
        • Pipeline run
    • Get help
    • Terminology
      • Project root directory
      • Dependencies
      • Standard development workflow
  • Visualisation with Kedro-Viz
    • Visualise the spaceflights project
      • Automatic visualisation updates
      • Visualise layers
      • Share a pipeline visualisation
    • Publish and share Kedro-Viz
      • Update and install the dependencies
      • Configure your AWS S3 bucket and set credentials
      • Publish and share the project
      • Permissions and access control
    • Preview data in Kedro-Viz
      • Configure the Data Catalog
      • Previewing Data on Kedro-viz
    • Visualise charts in Kedro-Viz
      • Visualisation with Plotly
        • Update the dependencies
        • Configure the Data Catalog
        • Create the template reporting pipeline
        • Add the Plotly reporting nodes
        • Update the reporting pipeline code
        • Run the pipeline
      • Visualisation with Matplotlib
        • Update the dependencies
        • Configure the Data Catalog
        • Add another node
        • Update the pipeline
        • Run the pipeline
  • Experiment tracking in Kedro-Viz
    • Kedro versions supporting experiment tracking
    • When should I use experiment tracking in Kedro?
    • Set up a project
      • Install Kedro and Kedro-Viz
      • Install the dependencies for the project
    • Set up the session store
      • Local storage
    • Collaborative experiment tracking
    • Set up experiment tracking datasets
    • Modify your nodes and pipelines to log metrics
    • Generate the run data
    • Access run data and compare runs
    • View and compare plots
      • Update the dependencies
      • Add a plotting node
    • View and compare metrics data
  • Kedro for notebook users
    • Add Kedro features to a notebook
      • Kedro spaceflights
        • The notebook example
      • Use Kedro for data processing
      • Use a YAML configuration file
        • Use a configuration file for “magic numbers”
        • Use a configuration file for all “magic values”
      • Use Kedro configuration
        • Use Kedro’s configuration loader to load “magic values”
        • Use Kedro’s configuration loader to load the Data Catalog
      • Where next?
      • Refactor your code into functions
    • Use a Jupyter notebook for Kedro project experiments
      • Iris dataset example
        • What does kedro jupyter notebook do?
      • How to explore a Kedro project in a notebook
        • %run_viz line magic
        • catalog
        • context
        • pipelines
        • session
      • How to use tags to convert functions from Jupyter notebooks into Kedro nodes
      • Useful to know (for advanced users)
        • Managed services
        • IPython, JupyterLab and other Jupyter clients
      • Find out more
  • FAQs and resources
    • FAQs
      • Visualisation
      • Working with Jupyter
      • Kedro project development
      • Configuration
        • Advanced topics
      • Nodes and pipelines
      • What is data engineering convention?
    • Kedro glossary
      • Data Catalog
      • Data engineering vs Data science
      • Kedro
      • KedroContext
      • KedroSession
      • Kedro-Viz
      • Layers (data engineering convention)
      • Modular pipeline
      • Node
      • Node execution order
      • Pipeline
      • Pipeline slicing
      • Runner
      • Starters
      • Tags
      • Workflow dependencies

Kedro projects

  • Configuration
    • Configuration
      • Configuration source
      • Configuration environments
        • Base
        • Local
      • Configuration loading
        • Configuration file names
        • Configuration patterns
      • How to use Kedro configuration
        • How to change the setting for a configuration source folder
        • How to change the configuration source folder at runtime
        • How to read configuration from a compressed file
        • How to access configuration in code
        • How to specify additional configuration environments
        • How to change the default overriding environment
        • How to use only one configuration environment
    • Credentials
      • How to load credentials in code
      • How to work with AWS credentials
    • Parameters
      • How to use parameters
      • How to load parameters in code
      • How to specify parameters at runtime
    • Migration guide for config loaders
      • ConfigLoader to OmegaConfigLoader
        • 1. Install the Required Library
        • 2. Use the OmegaConfigLoader
        • 3. Import Statements
        • 4. File Format Support
        • 5. Load Configuration
        • 6. Exception Handling
      • TemplatedConfigLoader to OmegaConfigLoader
        • 1. Install the required library
        • 2. Use the OmegaConfigLoader
        • 3. Import statements
        • 4. File format support
        • 5. Load configuration
        • 6. Templating of values
        • 7. Globals
        • 8. Deprecation of Jinja2
        • 9. Exception handling
    • Advanced configuration
      • OmegaConfigLoader
      • TemplatedConfigLoader
        • Provide template values through globals
      • Advanced Kedro configuration
        • How to change which configuration files are loaded
        • How to ensure non default configuration files get loaded
        • How to bypass the configuration loading rules
        • How to use Jinja2 syntax in configuration
        • How to do templating with the OmegaConfigLoader
        • How to use global variables with the OmegaConfigLoader
        • How to override configuration with runtime parameters with the OmegaConfigLoader
        • How to use resolvers in the OmegaConfigLoader
        • How to load credentials through environment variables
  • The Kedro Data Catalog
    • Introduction to the Data Catalog
      • The basics of catalog.yml
        • Dataset type
        • Dataset filepath
      • Additional settings in catalog.yml
        • Load and save arguments
        • Dataset access credentials
        • Dataset versioning
      • Use the Data Catalog within Kedro configuration
    • Data Catalog YAML examples
      • Load data from a local binary file using utf-8 encoding
      • Save data to a CSV file without row names (index) using utf-8 encoding
      • Load/save a CSV file from/to a local file system
      • Load/save a CSV on a local file system, using specified load/save arguments
      • Load/save a compressed CSV on a local file system
      • Load a CSV file from a specific S3 bucket, using credentials and load arguments
      • Load/save a pickle file from/to a local file system
      • Load an Excel file from Google Cloud Storage
      • Load a multi-sheet Excel file from a local file system
      • Save an image created with Matplotlib on Google Cloud Storage
      • Load/save an HDF file on local file system storage, using specified load/save arguments
      • Load/save a parquet file on local file system storage, using specified load/save arguments
      • Load/save a Spark table on S3, using specified load/save arguments
      • Load/save a SQL table using credentials, a database connection, and specified load/save arguments
      • Load a SQL table with credentials and a database connection, and apply a SQL query to the table
      • Load data from an API endpoint
      • Load data from Minio (S3 API Compatible Storage)
      • Load a model saved as a pickle from Azure Blob Storage
      • Load a CSV file stored in a remote location through SSH
      • Load multiple datasets with similar configuration using YAML anchors
      • Read the same file using two different datasets
      • Create a Data Catalog YAML configuration file via the CLI
    • Kedro dataset factories
      • How to generalise datasets with similar names and types
      • How to generalise datasets of the same type
      • How to generalise datasets using namespaces
      • How to generalise datasets of the same type in different layers
      • How to generalise datasets using multiple dataset factories
      • How to override the default dataset creation with dataset factories
      • CLI commands for dataset factories
        • How to use kedro catalog rank
        • How to use kedro catalog resolve
    • Advanced: Access the Data Catalog in code
      • How to configure the Data Catalog
      • How to view the available data sources
      • How to load datasets programmatically
      • How to save data programmatically
        • How to save data to memory
        • How to save data to a SQL database for querying
        • How to save data in Parquet
      • How to access a dataset with credentials
      • How to version a dataset using the Code API
    • Advanced: Partitioned and incremental datasets
      • Partitioned datasets
        • How to use PartitionedDataset
        • Dataset definition
        • Partitioned dataset credentials
        • Partitioned dataset load
        • Partitioned dataset save
        • Partitioned dataset lazy saving
      • Incremental datasets
        • Incremental dataset loads
        • Incremental dataset save
        • Incremental dataset confirm
        • Checkpoint configuration
        • Special checkpoint config keys
    • Advanced: Tutorial to create a custom dataset
      • AbstractDataset
      • Scenario
      • Project setup
      • The anatomy of a dataset
      • Implement the _load method with fsspec
      • Implement the _save method with fsspec
      • Implement the _describe method
      • The complete example
      • Integration with PartitionedDataset
      • Versioning
        • How to implement versioning in your dataset
      • Thread-safety
      • How to handle credentials and different filesystems
      • How to contribute a custom dataset implementation
  • Nodes and pipelines
    • Nodes
      • How to create a node
        • Node definition syntax
        • Syntax for input variables
        • Syntax for output variables
      • **kwargs-only node functions
      • How to tag a node
      • How to run a node
      • How to use generator functions in a node
        • Set up the project
        • Loading data with Generators
        • Saving data with Generators
    • Pipelines
      • How to build a pipeline
        • How to tag a pipeline
        • How to merge multiple pipelines
        • Information about the nodes in a pipeline
        • Information about pipeline inputs and outputs
      • Bad pipelines
        • Pipeline with bad nodes
        • Pipeline with circular dependencies
        • Pipeline nodes named with the dot notation
    • Modular pipelines
      • What are modular pipelines?
        • Key concepts
      • How do I create a modular pipeline?
        • What does kedro pipeline create do?
        • Custom templates
        • Ensuring portability
        • Providing modular pipeline specific dependencies
      • Using the modular pipeline() wrapper to provide overrides
      • Combining disconnected pipelines
      • Using a modular pipeline multiple times
      • How to use a modular pipeline with different parameters
    • The pipeline registry
      • Pipeline autodiscovery
    • Micro-packaging
      • Package a micro-package
      • Package multiple micro-packages
      • Pull a micro-package
        • Providing fsspec arguments
      • Pull multiple micro-packages
    • Run a pipeline
      • Runners
        • SequentialRunner
        • ParallelRunner
      • Custom runners
      • Load and save asynchronously
      • Run a pipeline by name
      • Run pipelines with IO
      • Output to a file
      • Configure kedro run arguments
    • Slice a pipeline
      • Slice a pipeline by providing inputs
      • Slice a pipeline by specifying nodes
      • Slice a pipeline by specifying final nodes
      • Slice a pipeline with tagged nodes
      • Slice a pipeline by running specified nodes
      • How to recreate missing outputs

Advanced usage

  • Project setup
    • Kedro starters
      • How to use Kedro starters
      • Starter aliases
      • List of official starters
      • Starter versioning
      • Use a starter with a configuration file
      • How to create a Kedro starter
        • Configuration variables
        • Example Kedro starter
    • Dependencies
      • Project-specific dependencies
      • Install project-specific dependencies
        • Install dependencies related to the Data Catalog
    • Lifecycle management with KedroSession
      • Overview
      • Create a session
    • Project settings
      • Application settings
      • Project metadata
  • Extend Kedro
    • Common use cases
      • Use Case 1: How to add extra behaviour to Kedro’s execution timeline
      • Use Case 2: How to integrate Kedro with additional data sources
      • Use Case 3: How to add or modify CLI commands
      • Use Case 4: How to customise the initial boilerplate of your project
    • Kedro plugins
      • Overview
      • Example of a simple plugin
      • Extend starter aliases
      • Working with click
      • Project context
      • Initialisation
      • global and project commands
      • Suggested command convention
      • Hooks
      • CLI Hooks
      • Contributing process
      • Supported Kedro plugins
      • Community-developed plugins
    • Kedro architecture overview
      • Kedro project
      • Kedro framework
      • Kedro starter
      • Kedro library
      • Kedro extension
  • Hooks
    • Hooks
      • Concepts
      • Hook specifications
        • CLI Hooks
      • Hook implementation
        • Define the Hook implementation
        • Registering the Hook implementation with Kedro
      • Hook execution order
      • Under the hood
        • Plugin Hooks
    • Common use cases
      • Use Hooks to extend a node’s behaviour
      • Use Hooks to customise the dataset load and save methods
      • Use Hooks to load external credentials
      • Use a Hook to read metadata from DataCatalog
    • Hooks examples
      • Add memory consumption tracking
      • Add data validation
        • V2 API
        • V3 API
      • Add observability to your pipeline
      • Add metrics tracking to your model
      • Modify node inputs using before_node_run hook
  • Logging
    • Default framework-side logging configuration
      • Project-side logging configuration
        • Using KEDRO_LOGGING_CONFIG environment variable
        • Disable file-based logging
        • Customise the rich Handler
        • Use plain console logging
        • Rich logging in a dumb terminal
        • Rich logging in Jupyter
      • Perform logging in your project
  • PySpark integration
    • Centralise Spark configuration in conf/base/spark.yml
    • Initialise a SparkSession using a hook
    • Use Kedro’s built-in Spark datasets to load and save raw data
    • Spark and Delta Lake interaction
    • Use MemoryDataset for intermediary DataFrame
    • Use MemoryDataset with copy_mode="assign" for non-DataFrame Spark objects
    • Tips for maximising concurrency using ThreadRunner
  • Development
    • Set up Visual Studio Code
      • Advanced: For those using venv / virtualenv
      • Setting up tasks
      • Debugging
        • Advanced: Remote Interpreter / Debugging
      • Configuring the Kedro catalog validation schema
    • Set up PyCharm
      • Set up Run configurations
      • Debugging
      • Advanced: Remote SSH interpreter
      • Advanced: Docker interpreter
      • Configure Python Console
      • Configuring the Kedro catalog validation schema
    • Kedro’s command line interface
      • Autocompletion (optional)
      • Invoke Kedro CLI from Python (optional)
      • Kedro commands
      • Global Kedro commands
        • Get help on Kedro commands
        • Confirm the Kedro version
        • Confirm Kedro information
        • Create a new Kedro project
        • Open the Kedro documentation in your browser
      • Customise or Override Project-specific Kedro commands
        • Project setup
        • Run the project
        • Deploy the project
        • Pull a micro-package
        • Project quality
        • Project development
    • Debugging
      • Introduction
      • Debugging Node
      • Debugging Pipeline
    • Automated Testing
      • Introduction
      • Set up automated testing with pytest
        • Install pytest
        • Create a /tests directory
        • Test directory structure
        • Create an example test
        • Run your tests
      • Add test coverage reports with pytest-cov
        • Install pytest-cov
        • Configure pytest to use pytest-cov
        • Run pytest with pytest-cov
    • Code formatting and linting
      • Introduction
      • Set up Python tools
        • Install the tools
        • Run the tools
      • Automated formatting and linting with pre-commit hooks
        • Install pre-commit
        • Add pre-commit configuration file
        • Install git hook scripts
  • Deployment
    • Single-machine deployment
      • Container-based
        • How to use container registry
      • Package-based
      • CLI-based
        • Use GitHub workflow to copy your project
        • Install and run the Kedro project
    • Distributed deployment
      • 1. Containerise the pipeline
      • 2. Convert your Kedro pipeline into targeted platform primitives
      • 3. Parameterise the runs
      • 4. (Optional) Create starters
    • Apache Airflow
      • How to run a Kedro pipeline on Apache Airflow using a Kubernetes cluster
      • How to run a Kedro pipeline on Apache Airflow with Astronomer
        • Strategy
        • Prerequisites
        • Tutorial project setup
        • Deployment process
    • Amazon SageMaker
      • The kedro-sagemaker plugin
    • Amazon EMR Serverless
      • Context
      • Overview of approach
        • Resources
      • Setup
        • Prerequisites
        • Infrastructure
        • IAM
      • (Optional) Validate the custom image
      • Run a job
      • FAQ
        • How is the approach defined here different from the approach in “Seven steps to deploy Kedro pipelines on Amazon EMR” on the Kedro blog?
        • EMR Serverless already has Python installed. Why do we need a custom Python version?
        • Why do we need to create a custom image to provide the custom Python version?
        • Why do we need to package the Kedro project and invoke using an entrypoint script? Why can’t we use [CMD] or [ENTRYPOINT] with kedro run in the custom image?
        • How about using the method described in Lifecycle management with KedroSession to run Kedro programmatically?
    • AWS Step Functions
      • Why would you run a Kedro pipeline with AWS Step Functions?
      • Strategy
      • Prerequisites
      • Deployment process
        • Step 1. Create new configuration environment to prepare a compatible DataCatalog
        • Step 2. Package the Kedro pipeline as an AWS Lambda-compliant Docker image
        • Step 3. Write the deployment script
        • Step 4. Deploy the pipeline
      • Limitations
    • Azure ML pipelines
      • kedro-azureml plugin
    • Dask
      • Why would you use Dask?
      • Prerequisites
      • How to distribute your Kedro pipeline using Dask
        • Create a custom runner
        • Update CLI implementation
        • Deploy
    • Databricks
      • Use a Databricks workspace to develop a Kedro project
        • What this page covers
        • Prerequisites
        • Set up your project
        • Modify your project and test the changes
        • Summary
      • Use an IDE, dbx and Databricks Repos to develop a Kedro project
        • What this page covers
        • Prerequisites
        • Set up your project
        • Modify your project and test the changes
        • Summary
      • Use a Databricks job to deploy a Kedro project
        • What are the advantages of packaging a Kedro project to run on Databricks?
        • What this page covers
        • Prerequisites
        • Set up your project for deployment to Databricks
        • Deploy and run your Kedro project using the workspace UI
        • Resources for automatically deploying to Databricks
        • Summary
      • Visualise a Kedro project in Databricks notebooks
    • Kubeflow Pipelines
      • Why would you use Kubeflow Pipelines?
      • The kedro-kubeflow plugin
    • Prefect
      • Prerequisites
      • Setup
      • How to run your Kedro pipeline using Prefect 2.0
        • Convert your Kedro pipeline to Prefect 2.0 flow
        • Run Prefect flow
    • VertexAI
      • The kedro-vertexai plugin
    • Argo Workflows (outdated documentation that needs review)
      • Why would you use Argo Workflows?
      • Prerequisites
      • How to run your Kedro pipeline using Argo Workflows
        • Containerise your Kedro project
        • Create Argo Workflows spec
        • Submit Argo Workflows spec to Kubernetes
        • Kedro-Argo plugin
    • AWS Batch (outdated documentation that needs review)
      • Why would you use AWS Batch?
      • Prerequisites
      • How to run a Kedro pipeline using AWS Batch
        • Containerise your Kedro project
        • Provision resources
        • Configure the credentials
        • Submit AWS Batch jobs
        • Deploy

Contribute to Kedro

  • Contribute to Kedro
    • Kedro’s Technical Steering Committee
      • Responsibilities of a maintainer
        • Product development
        • Community management
      • Requirements to become a maintainer
      • Current maintainers
      • Past maintainers
      • Application process
      • Voting process
        • Other issues or proposals
        • Adding or removing maintainers

API documentation

  • kedro
    • kedro.KedroDeprecationWarning
      • KedroDeprecationWarning
        • KedroDeprecationWarning.args
        • KedroDeprecationWarning.with_traceback()
    • kedro.KedroPythonVersionWarning
      • KedroPythonVersionWarning
        • KedroPythonVersionWarning.args
        • KedroPythonVersionWarning.with_traceback()
    • kedro.config
      • kedro.config.ConfigLoader
        • ConfigLoader
      • kedro.config.TemplatedConfigLoader
        • TemplatedConfigLoader
      • kedro.config.OmegaConfigLoader
        • OmegaConfigLoader
      • kedro.config.MissingConfigException
        • MissingConfigException
    • kedro.extras
      • kedro.extras.extensions
        • kedro.extras.extensions.ipython
      • kedro.extras.logging
        • kedro.extras.logging.color_logger
      • kedro.extras.datasets
        • kedro.extras.datasets.api.APIDataSet
        • kedro.extras.datasets.biosequence.BioSequenceDataSet
        • kedro.extras.datasets.dask.ParquetDataSet
        • kedro.extras.datasets.email.EmailMessageDataSet
        • kedro.extras.datasets.geopandas.GeoJSONDataSet
        • kedro.extras.datasets.holoviews.HoloviewsWriter
        • kedro.extras.datasets.json.JSONDataSet
        • kedro.extras.datasets.matplotlib.MatplotlibWriter
        • kedro.extras.datasets.networkx.GMLDataSet
        • kedro.extras.datasets.networkx.GraphMLDataSet
        • kedro.extras.datasets.networkx.JSONDataSet
        • kedro.extras.datasets.pandas.CSVDataSet
        • kedro.extras.datasets.pandas.ExcelDataSet
        • kedro.extras.datasets.pandas.FeatherDataSet
        • kedro.extras.datasets.pandas.GBQQueryDataSet
        • kedro.extras.datasets.pandas.GBQTableDataSet
        • kedro.extras.datasets.pandas.GenericDataSet
        • kedro.extras.datasets.pandas.HDFDataSet
        • kedro.extras.datasets.pandas.JSONDataSet
        • kedro.extras.datasets.pandas.ParquetDataSet
        • kedro.extras.datasets.pandas.SQLQueryDataSet
        • kedro.extras.datasets.pandas.SQLTableDataSet
        • kedro.extras.datasets.pandas.XMLDataSet
        • kedro.extras.datasets.pickle.PickleDataSet
        • kedro.extras.datasets.pillow.ImageDataSet
        • kedro.extras.datasets.plotly.JSONDataSet
        • kedro.extras.datasets.plotly.PlotlyDataSet
        • kedro.extras.datasets.redis.PickleDataSet
        • kedro.extras.datasets.spark.DeltaTableDataSet
        • kedro.extras.datasets.spark.SparkDataSet
        • kedro.extras.datasets.spark.SparkHiveDataSet
        • kedro.extras.datasets.spark.SparkJDBCDataSet
        • kedro.extras.datasets.svmlight.SVMLightDataSet
        • kedro.extras.datasets.tensorflow.TensorFlowModelDataset
        • kedro.extras.datasets.text.TextDataSet
        • kedro.extras.datasets.tracking.JSONDataSet
        • kedro.extras.datasets.tracking.MetricsDataSet
        • kedro.extras.datasets.yaml.YAMLDataSet
    • kedro.framework
      • kedro.framework.cli
        • kedro.framework.cli.catalog
        • kedro.framework.cli.cli
        • kedro.framework.cli.hooks
        • kedro.framework.cli.jupyter
        • kedro.framework.cli.micropkg
        • kedro.framework.cli.pipeline
        • kedro.framework.cli.project
        • kedro.framework.cli.registry
        • kedro.framework.cli.starters
        • kedro.framework.cli.utils
      • kedro.framework.context
        • kedro.framework.context.KedroContext
        • kedro.framework.context.KedroContextError
      • kedro.framework.hooks
        • kedro.framework.hooks.manager
        • kedro.framework.hooks.markers
        • kedro.framework.hooks.specs
      • kedro.framework.project
        • kedro.framework.project.configure_logging
        • kedro.framework.project.configure_project
        • kedro.framework.project.find_pipelines
        • kedro.framework.project.validate_settings
      • kedro.framework.session
        • kedro.framework.session.session
        • kedro.framework.session.shelvestore
        • kedro.framework.session.store
      • kedro.framework.startup
        • kedro.framework.startup.bootstrap_project
        • kedro.framework.startup.ProjectMetadata
    • kedro.io
      • kedro.io.AbstractDataset
        • AbstractDataset
      • kedro.io.AbstractVersionedDataset
        • AbstractVersionedDataset
      • kedro.io.CachedDataSet
        • CachedDataSet
      • kedro.io.CachedDataset
        • CachedDataset
      • kedro.io.DataCatalog
        • DataCatalog
      • kedro.io.IncrementalDataSet
        • IncrementalDataSet
      • kedro.io.IncrementalDataset
        • IncrementalDataset
      • kedro.io.LambdaDataSet
        • LambdaDataSet
      • kedro.io.LambdaDataset
        • LambdaDataset
      • kedro.io.MemoryDataSet
        • MemoryDataSet
      • kedro.io.MemoryDataset
        • MemoryDataset
      • kedro.io.PartitionedDataSet
        • PartitionedDataSet
      • kedro.io.PartitionedDataset
        • PartitionedDataset
      • kedro.io.Version
        • Version
      • kedro.io.DataSetAlreadyExistsError
        • DataSetAlreadyExistsError
      • kedro.io.DataSetError
        • DataSetError
      • kedro.io.DataSetNotFoundError
        • DataSetNotFoundError
      • kedro.io.DatasetAlreadyExistsError
        • DatasetAlreadyExistsError
      • kedro.io.DatasetError
        • DatasetError
      • kedro.io.DatasetNotFoundError
        • DatasetNotFoundError
    • kedro.ipython
      • kedro.ipython.load_ipython_extension
        • load_ipython_extension()
      • kedro.ipython.magic_reload_kedro
        • magic_reload_kedro()
      • kedro.ipython.reload_kedro
        • reload_kedro()
    • kedro.logging
      • kedro.logging.RichHandler
        • RichHandler
    • kedro.pipeline
      • kedro.pipeline.node
        • node()
      • kedro.pipeline.modular_pipeline.pipeline
        • pipeline()
      • kedro.pipeline.Pipeline
        • Pipeline
      • kedro.pipeline.node.Node
        • Node
      • kedro.pipeline.modular_pipeline.ModularPipelineError
        • ModularPipelineError
    • kedro.runner
      • kedro.runner.run_node
        • run_node()
      • kedro.runner.AbstractRunner
        • AbstractRunner
      • kedro.runner.ParallelRunner
        • ParallelRunner
      • kedro.runner.SequentialRunner
        • SequentialRunner
      • kedro.runner.ThreadRunner
        • ThreadRunner
    • kedro.utils
      • kedro.utils.load_obj
        • load_obj()
  • kedro_datasets
    • kedro_datasets.api.APIDataSet
      • APIDataSet
    • kedro_datasets.api.APIDataset
      • APIDataset
        • APIDataset.DEFAULT_SAVE_ARGS
        • APIDataset.__init__()
        • APIDataset.exists()
        • APIDataset.from_config()
        • APIDataset.load()
        • APIDataset.release()
        • APIDataset.save()
    • kedro_datasets.biosequence.BioSequenceDataSet
      • BioSequenceDataSet
    • kedro_datasets.biosequence.BioSequenceDataset
      • BioSequenceDataset
        • BioSequenceDataset.DEFAULT_LOAD_ARGS
        • BioSequenceDataset.DEFAULT_SAVE_ARGS
        • BioSequenceDataset.__init__()
        • BioSequenceDataset.exists()
        • BioSequenceDataset.from_config()
        • BioSequenceDataset.invalidate_cache()
        • BioSequenceDataset.load()
        • BioSequenceDataset.release()
        • BioSequenceDataset.save()
    • kedro_datasets.dask.ParquetDataSet
      • ParquetDataSet
    • kedro_datasets.dask.ParquetDataset
      • ParquetDataset
        • ParquetDataset.DEFAULT_LOAD_ARGS
        • ParquetDataset.DEFAULT_SAVE_ARGS
        • ParquetDataset.__init__()
        • ParquetDataset.exists()
        • ParquetDataset.from_config()
        • ParquetDataset.fs_args
        • ParquetDataset.load()
        • ParquetDataset.release()
        • ParquetDataset.save()
    • kedro_datasets.databricks.ManagedTableDataSet
      • ManagedTableDataSet
    • kedro_datasets.databricks.ManagedTableDataset
      • ManagedTableDataset
        • ManagedTableDataset.__init__()
        • ManagedTableDataset.exists()
        • ManagedTableDataset.from_config()
        • ManagedTableDataset.load()
        • ManagedTableDataset.release()
        • ManagedTableDataset.resolve_load_version()
        • ManagedTableDataset.resolve_save_version()
        • ManagedTableDataset.save()
    • kedro_datasets.email.EmailMessageDataSet
      • EmailMessageDataSet
    • kedro_datasets.email.EmailMessageDataset
      • EmailMessageDataset
        • EmailMessageDataset.DEFAULT_LOAD_ARGS
        • EmailMessageDataset.DEFAULT_SAVE_ARGS
        • EmailMessageDataset.__init__()
        • EmailMessageDataset.exists()
        • EmailMessageDataset.from_config()
        • EmailMessageDataset.load()
        • EmailMessageDataset.release()
        • EmailMessageDataset.resolve_load_version()
        • EmailMessageDataset.resolve_save_version()
        • EmailMessageDataset.save()
    • kedro_datasets.geopandas.GeoJSONDataSet
      • GeoJSONDataSet
    • kedro_datasets.geopandas.GeoJSONDataset
      • GeoJSONDataset
        • GeoJSONDataset.DEFAULT_LOAD_ARGS
        • GeoJSONDataset.DEFAULT_SAVE_ARGS
        • GeoJSONDataset.__init__()
        • GeoJSONDataset.exists()
        • GeoJSONDataset.from_config()
        • GeoJSONDataset.invalidate_cache()
        • GeoJSONDataset.load()
        • GeoJSONDataset.release()
        • GeoJSONDataset.resolve_load_version()
        • GeoJSONDataset.resolve_save_version()
        • GeoJSONDataset.save()
    • kedro_datasets.holoviews.HoloviewsWriter
      • HoloviewsWriter
        • HoloviewsWriter.DEFAULT_SAVE_ARGS
        • HoloviewsWriter.__init__()
        • HoloviewsWriter.exists()
        • HoloviewsWriter.from_config()
        • HoloviewsWriter.load()
        • HoloviewsWriter.release()
        • HoloviewsWriter.resolve_load_version()
        • HoloviewsWriter.resolve_save_version()
        • HoloviewsWriter.save()
    • kedro_datasets.json.JSONDataSet
      • JSONDataSet
    • kedro_datasets.json.JSONDataset
      • JSONDataset
        • JSONDataset.DEFAULT_SAVE_ARGS
        • JSONDataset.__init__()
        • JSONDataset.exists()
        • JSONDataset.from_config()
        • JSONDataset.load()
        • JSONDataset.release()
        • JSONDataset.resolve_load_version()
        • JSONDataset.resolve_save_version()
        • JSONDataset.save()
    • kedro_datasets.matplotlib.MatplotlibWriter
      • MatplotlibWriter
        • MatplotlibWriter.DEFAULT_SAVE_ARGS
        • MatplotlibWriter.__init__()
        • MatplotlibWriter.exists()
        • MatplotlibWriter.from_config()
        • MatplotlibWriter.load()
        • MatplotlibWriter.release()
        • MatplotlibWriter.resolve_load_version()
        • MatplotlibWriter.resolve_save_version()
        • MatplotlibWriter.save()
    • kedro_datasets.networkx.GMLDataSet
      • GMLDataSet
    • kedro_datasets.networkx.GMLDataset
      • GMLDataset
        • GMLDataset.DEFAULT_LOAD_ARGS
        • GMLDataset.DEFAULT_SAVE_ARGS
        • GMLDataset.__init__()
        • GMLDataset.exists()
        • GMLDataset.from_config()
        • GMLDataset.load()
        • GMLDataset.release()
        • GMLDataset.resolve_load_version()
        • GMLDataset.resolve_save_version()
        • GMLDataset.save()
    • kedro_datasets.networkx.GraphMLDataSet
      • GraphMLDataSet
    • kedro_datasets.networkx.GraphMLDataset
      • GraphMLDataset
        • GraphMLDataset.DEFAULT_LOAD_ARGS
        • GraphMLDataset.DEFAULT_SAVE_ARGS
        • GraphMLDataset.__init__()
        • GraphMLDataset.exists()
        • GraphMLDataset.from_config()
        • GraphMLDataset.load()
        • GraphMLDataset.release()
        • GraphMLDataset.resolve_load_version()
        • GraphMLDataset.resolve_save_version()
        • GraphMLDataset.save()
    • kedro_datasets.networkx.JSONDataSet
      • JSONDataSet
    • kedro_datasets.networkx.JSONDataset
      • JSONDataset
        • JSONDataset.DEFAULT_LOAD_ARGS
        • JSONDataset.DEFAULT_SAVE_ARGS
        • JSONDataset.__init__()
        • JSONDataset.exists()
        • JSONDataset.from_config()
        • JSONDataset.load()
        • JSONDataset.release()
        • JSONDataset.resolve_load_version()
        • JSONDataset.resolve_save_version()
        • JSONDataset.save()
    • kedro_datasets.pandas.CSVDataSet
      • CSVDataSet
    • kedro_datasets.pandas.CSVDataset
      • CSVDataset
        • CSVDataset.DEFAULT_LOAD_ARGS
        • CSVDataset.DEFAULT_SAVE_ARGS
        • CSVDataset.__init__()
        • CSVDataset.exists()
        • CSVDataset.from_config()
        • CSVDataset.load()
        • CSVDataset.release()
        • CSVDataset.resolve_load_version()
        • CSVDataset.resolve_save_version()
        • CSVDataset.save()
    • kedro_datasets.pandas.DeltaTableDataSet
      • DeltaTableDataSet
    • kedro_datasets.pandas.DeltaTableDataset
      • DeltaTableDataset
        • DeltaTableDataset.ACCEPTED_WRITE_MODES
        • DeltaTableDataset.DEFAULT_LOAD_ARGS
        • DeltaTableDataset.DEFAULT_SAVE_ARGS
        • DeltaTableDataset.DEFAULT_WRITE_MODE
        • DeltaTableDataset.__init__()
        • DeltaTableDataset.exists()
        • DeltaTableDataset.from_config()
        • DeltaTableDataset.fs_args
        • DeltaTableDataset.get_loaded_version()
        • DeltaTableDataset.history
        • DeltaTableDataset.load()
        • DeltaTableDataset.metadata
        • DeltaTableDataset.release()
        • DeltaTableDataset.save()
        • DeltaTableDataset.schema
    • kedro_datasets.pandas.ExcelDataSet
      • ExcelDataSet
    • kedro_datasets.pandas.ExcelDataset
      • ExcelDataset
        • ExcelDataset.DEFAULT_LOAD_ARGS
        • ExcelDataset.DEFAULT_SAVE_ARGS
        • ExcelDataset.__init__()
        • ExcelDataset.exists()
        • ExcelDataset.from_config()
        • ExcelDataset.load()
        • ExcelDataset.release()
        • ExcelDataset.resolve_load_version()
        • ExcelDataset.resolve_save_version()
        • ExcelDataset.save()
    • kedro_datasets.pandas.FeatherDataSet
      • FeatherDataSet
    • kedro_datasets.pandas.FeatherDataset
      • FeatherDataset
        • FeatherDataset.DEFAULT_LOAD_ARGS
        • FeatherDataset.DEFAULT_SAVE_ARGS
        • FeatherDataset.__init__()
        • FeatherDataset.exists()
        • FeatherDataset.from_config()
        • FeatherDataset.load()
        • FeatherDataset.release()
        • FeatherDataset.resolve_load_version()
        • FeatherDataset.resolve_save_version()
        • FeatherDataset.save()
    • kedro_datasets.pandas.GBQQueryDataSet
      • GBQQueryDataSet
    • kedro_datasets.pandas.GBQQueryDataset
      • GBQQueryDataset
        • GBQQueryDataset.DEFAULT_LOAD_ARGS
        • GBQQueryDataset.__init__()
        • GBQQueryDataset.exists()
        • GBQQueryDataset.from_config()
        • GBQQueryDataset.load()
        • GBQQueryDataset.release()
        • GBQQueryDataset.save()
    • kedro_datasets.pandas.GBQTableDataSet
      • GBQTableDataSet
    • kedro_datasets.pandas.GBQTableDataset
      • GBQTableDataset
        • GBQTableDataset.DEFAULT_LOAD_ARGS
        • GBQTableDataset.DEFAULT_SAVE_ARGS
        • GBQTableDataset.__init__()
        • GBQTableDataset.exists()
        • GBQTableDataset.from_config()
        • GBQTableDataset.load()
        • GBQTableDataset.release()
        • GBQTableDataset.save()
    • kedro_datasets.pandas.GenericDataSet
      • GenericDataSet
    • kedro_datasets.pandas.GenericDataset
      • GenericDataset
        • GenericDataset.DEFAULT_LOAD_ARGS
        • GenericDataset.DEFAULT_SAVE_ARGS
        • GenericDataset.__init__()
        • GenericDataset.exists()
        • GenericDataset.from_config()
        • GenericDataset.load()
        • GenericDataset.release()
        • GenericDataset.resolve_load_version()
        • GenericDataset.resolve_save_version()
        • GenericDataset.save()
    • kedro_datasets.pandas.HDFDataSet
      • HDFDataSet
    • kedro_datasets.pandas.HDFDataset
      • HDFDataset
        • HDFDataset.DEFAULT_LOAD_ARGS
        • HDFDataset.DEFAULT_SAVE_ARGS
        • HDFDataset.__init__()
        • HDFDataset.exists()
        • HDFDataset.from_config()
        • HDFDataset.load()
        • HDFDataset.release()
        • HDFDataset.resolve_load_version()
        • HDFDataset.resolve_save_version()
        • HDFDataset.save()
    • kedro_datasets.pandas.JSONDataSet
      • JSONDataSet
    • kedro_datasets.pandas.JSONDataset
      • JSONDataset
        • JSONDataset.DEFAULT_LOAD_ARGS
        • JSONDataset.DEFAULT_SAVE_ARGS
        • JSONDataset.__init__()
        • JSONDataset.exists()
        • JSONDataset.from_config()
        • JSONDataset.load()
        • JSONDataset.release()
        • JSONDataset.resolve_load_version()
        • JSONDataset.resolve_save_version()
        • JSONDataset.save()
    • kedro_datasets.pandas.ParquetDataSet
      • ParquetDataSet
    • kedro_datasets.pandas.ParquetDataset
      • ParquetDataset
        • ParquetDataset.DEFAULT_LOAD_ARGS
        • ParquetDataset.DEFAULT_SAVE_ARGS
        • ParquetDataset.__init__()
        • ParquetDataset.exists()
        • ParquetDataset.from_config()
        • ParquetDataset.load()
        • ParquetDataset.release()
        • ParquetDataset.resolve_load_version()
        • ParquetDataset.resolve_save_version()
        • ParquetDataset.save()
    • kedro_datasets.pandas.SQLQueryDataSet
      • SQLQueryDataSet
    • kedro_datasets.pandas.SQLQueryDataset
      • SQLQueryDataset
        • SQLQueryDataset.__init__()
        • SQLQueryDataset.adapt_mssql_date_params()
        • SQLQueryDataset.create_connection()
        • SQLQueryDataset.engines
        • SQLQueryDataset.exists()
        • SQLQueryDataset.from_config()
        • SQLQueryDataset.load()
        • SQLQueryDataset.release()
        • SQLQueryDataset.save()
    • kedro_datasets.pandas.SQLTableDataSet
      • SQLTableDataSet
    • kedro_datasets.pandas.SQLTableDataset
      • SQLTableDataset
        • SQLTableDataset.DEFAULT_LOAD_ARGS
        • SQLTableDataset.DEFAULT_SAVE_ARGS
        • SQLTableDataset.__init__()
        • SQLTableDataset.create_connection()
        • SQLTableDataset.engines
        • SQLTableDataset.exists()
        • SQLTableDataset.from_config()
        • SQLTableDataset.load()
        • SQLTableDataset.release()
        • SQLTableDataset.save()
    • kedro_datasets.pandas.XMLDataSet
      • XMLDataSet
    • kedro_datasets.pandas.XMLDataset
      • XMLDataset
        • XMLDataset.DEFAULT_LOAD_ARGS
        • XMLDataset.DEFAULT_SAVE_ARGS
        • XMLDataset.__init__()
        • XMLDataset.exists()
        • XMLDataset.from_config()
        • XMLDataset.load()
        • XMLDataset.release()
        • XMLDataset.resolve_load_version()
        • XMLDataset.resolve_save_version()
        • XMLDataset.save()
    • kedro_datasets.pickle.PickleDataSet
      • PickleDataSet
    • kedro_datasets.pickle.PickleDataset
      • PickleDataset
        • PickleDataset.DEFAULT_LOAD_ARGS
        • PickleDataset.DEFAULT_SAVE_ARGS
        • PickleDataset.__init__()
        • PickleDataset.exists()
        • PickleDataset.from_config()
        • PickleDataset.load()
        • PickleDataset.release()
        • PickleDataset.resolve_load_version()
        • PickleDataset.resolve_save_version()
        • PickleDataset.save()
    • kedro_datasets.pillow.ImageDataSet
      • ImageDataSet
    • kedro_datasets.pillow.ImageDataset
      • ImageDataset
        • ImageDataset.DEFAULT_SAVE_ARGS
        • ImageDataset.__init__()
        • ImageDataset.exists()
        • ImageDataset.from_config()
        • ImageDataset.load()
        • ImageDataset.release()
        • ImageDataset.resolve_load_version()
        • ImageDataset.resolve_save_version()
        • ImageDataset.save()
    • kedro_datasets.plotly.JSONDataSet
      • JSONDataSet
    • kedro_datasets.plotly.JSONDataset
      • JSONDataset
        • JSONDataset.DEFAULT_LOAD_ARGS
        • JSONDataset.DEFAULT_SAVE_ARGS
        • JSONDataset.__init__()
        • JSONDataset.exists()
        • JSONDataset.from_config()
        • JSONDataset.load()
        • JSONDataset.release()
        • JSONDataset.resolve_load_version()
        • JSONDataset.resolve_save_version()
        • JSONDataset.save()
    • kedro_datasets.plotly.PlotlyDataSet
      • PlotlyDataSet
    • kedro_datasets.plotly.PlotlyDataset
      • PlotlyDataset
        • PlotlyDataset.DEFAULT_LOAD_ARGS
        • PlotlyDataset.DEFAULT_SAVE_ARGS
        • PlotlyDataset.__init__()
        • PlotlyDataset.exists()
        • PlotlyDataset.from_config()
        • PlotlyDataset.load()
        • PlotlyDataset.release()
        • PlotlyDataset.resolve_load_version()
        • PlotlyDataset.resolve_save_version()
        • PlotlyDataset.save()
    • kedro_datasets.polars.CSVDataSet
      • CSVDataSet
    • kedro_datasets.polars.CSVDataset
      • CSVDataset
        • CSVDataset.DEFAULT_LOAD_ARGS
        • CSVDataset.DEFAULT_SAVE_ARGS
        • CSVDataset.__init__()
        • CSVDataset.exists()
        • CSVDataset.from_config()
        • CSVDataset.load()
        • CSVDataset.release()
        • CSVDataset.resolve_load_version()
        • CSVDataset.resolve_save_version()
        • CSVDataset.save()
    • kedro_datasets.polars.GenericDataSet
      • GenericDataSet
    • kedro_datasets.polars.GenericDataset
      • GenericDataset
        • GenericDataset.DEFAULT_LOAD_ARGS
        • GenericDataset.DEFAULT_SAVE_ARGS
        • GenericDataset.__init__()
        • GenericDataset.exists()
        • GenericDataset.from_config()
        • GenericDataset.load()
        • GenericDataset.release()
        • GenericDataset.resolve_load_version()
        • GenericDataset.resolve_save_version()
        • GenericDataset.save()
    • kedro_datasets.redis.PickleDataSet
      • PickleDataSet
    • kedro_datasets.redis.PickleDataset
      • PickleDataset
        • PickleDataset.DEFAULT_LOAD_ARGS
        • PickleDataset.DEFAULT_REDIS_URL
        • PickleDataset.DEFAULT_SAVE_ARGS
        • PickleDataset.__init__()
        • PickleDataset.exists()
        • PickleDataset.from_config()
        • PickleDataset.load()
        • PickleDataset.release()
        • PickleDataset.save()
    • kedro_datasets.snowflake.SnowparkTableDataSet
      • SnowparkTableDataSet
    • kedro_datasets.snowflake.SnowparkTableDataset
      • SnowparkTableDataset
        • SnowparkTableDataset.DEFAULT_LOAD_ARGS
        • SnowparkTableDataset.DEFAULT_SAVE_ARGS
        • SnowparkTableDataset.__init__()
        • SnowparkTableDataset.exists()
        • SnowparkTableDataset.from_config()
        • SnowparkTableDataset.load()
        • SnowparkTableDataset.release()
        • SnowparkTableDataset.save()
    • kedro_datasets.spark.DeltaTableDataSet
      • DeltaTableDataSet
    • kedro_datasets.spark.DeltaTableDataset
      • DeltaTableDataset
        • DeltaTableDataset.__init__()
        • DeltaTableDataset.exists()
        • DeltaTableDataset.from_config()
        • DeltaTableDataset.load()
        • DeltaTableDataset.release()
        • DeltaTableDataset.save()
    • kedro_datasets.spark.SparkDataSet
      • SparkDataSet
    • kedro_datasets.spark.SparkDataset
      • SparkDataset
        • SparkDataset.DEFAULT_LOAD_ARGS
        • SparkDataset.DEFAULT_SAVE_ARGS
        • SparkDataset.__init__()
        • SparkDataset.exists()
        • SparkDataset.from_config()
        • SparkDataset.load()
        • SparkDataset.release()
        • SparkDataset.resolve_load_version()
        • SparkDataset.resolve_save_version()
        • SparkDataset.save()
    • kedro_datasets.spark.SparkHiveDataSet
      • SparkHiveDataSet
    • kedro_datasets.spark.SparkHiveDataset
      • SparkHiveDataset
        • SparkHiveDataset.DEFAULT_SAVE_ARGS
        • SparkHiveDataset.__init__()
        • SparkHiveDataset.exists()
        • SparkHiveDataset.from_config()
        • SparkHiveDataset.load()
        • SparkHiveDataset.release()
        • SparkHiveDataset.save()
    • kedro_datasets.spark.SparkJDBCDataSet
      • SparkJDBCDataSet
    • kedro_datasets.spark.SparkJDBCDataset
      • SparkJDBCDataset
        • SparkJDBCDataset.DEFAULT_LOAD_ARGS
        • SparkJDBCDataset.DEFAULT_SAVE_ARGS
        • SparkJDBCDataset.__init__()
        • SparkJDBCDataset.exists()
        • SparkJDBCDataset.from_config()
        • SparkJDBCDataset.load()
        • SparkJDBCDataset.release()
        • SparkJDBCDataset.save()
    • kedro_datasets.spark.SparkStreamingDataSet
      • SparkStreamingDataSet
    • kedro_datasets.spark.SparkStreamingDataset
      • SparkStreamingDataset
        • SparkStreamingDataset.DEFAULT_LOAD_ARGS
        • SparkStreamingDataset.DEFAULT_SAVE_ARGS
        • SparkStreamingDataset.__init__()
        • SparkStreamingDataset.exists()
        • SparkStreamingDataset.from_config()
        • SparkStreamingDataset.load()
        • SparkStreamingDataset.release()
        • SparkStreamingDataset.save()
    • kedro_datasets.svmlight.SVMLightDataSet
      • SVMLightDataSet
    • kedro_datasets.svmlight.SVMLightDataset
      • SVMLightDataset
        • SVMLightDataset.DEFAULT_LOAD_ARGS
        • SVMLightDataset.DEFAULT_SAVE_ARGS
        • SVMLightDataset.__init__()
        • SVMLightDataset.exists()
        • SVMLightDataset.from_config()
        • SVMLightDataset.load()
        • SVMLightDataset.release()
        • SVMLightDataset.resolve_load_version()
        • SVMLightDataset.resolve_save_version()
        • SVMLightDataset.save()
    • kedro_datasets.tensorflow.TensorFlowModelDataSet
      • TensorFlowModelDataSet
    • kedro_datasets.tensorflow.TensorFlowModelDataset
      • TensorFlowModelDataset
        • TensorFlowModelDataset.DEFAULT_LOAD_ARGS
        • TensorFlowModelDataset.DEFAULT_SAVE_ARGS
        • TensorFlowModelDataset.__init__()
        • TensorFlowModelDataset.exists()
        • TensorFlowModelDataset.from_config()
        • TensorFlowModelDataset.load()
        • TensorFlowModelDataset.release()
        • TensorFlowModelDataset.resolve_load_version()
        • TensorFlowModelDataset.resolve_save_version()
        • TensorFlowModelDataset.save()
    • kedro_datasets.text.TextDataSet
      • TextDataSet
    • kedro_datasets.text.TextDataset
      • TextDataset
        • TextDataset.__init__()
        • TextDataset.exists()
        • TextDataset.from_config()
        • TextDataset.load()
        • TextDataset.release()
        • TextDataset.resolve_load_version()
        • TextDataset.resolve_save_version()
        • TextDataset.save()
    • kedro_datasets.tracking.JSONDataSet
      • JSONDataSet
    • kedro_datasets.tracking.JSONDataset
      • JSONDataset
        • JSONDataset.DEFAULT_SAVE_ARGS
        • JSONDataset.__init__()
        • JSONDataset.exists()
        • JSONDataset.from_config()
        • JSONDataset.load()
        • JSONDataset.release()
        • JSONDataset.resolve_load_version()
        • JSONDataset.resolve_save_version()
        • JSONDataset.save()
        • JSONDataset.versioned
    • kedro_datasets.tracking.MetricsDataSet
      • MetricsDataSet
    • kedro_datasets.tracking.MetricsDataset
      • MetricsDataset
        • MetricsDataset.DEFAULT_SAVE_ARGS
        • MetricsDataset.__init__()
        • MetricsDataset.exists()
        • MetricsDataset.from_config()
        • MetricsDataset.load()
        • MetricsDataset.release()
        • MetricsDataset.resolve_load_version()
        • MetricsDataset.resolve_save_version()
        • MetricsDataset.save()
        • MetricsDataset.versioned
    • kedro_datasets.video.VideoDataSet
      • VideoDataSet
    • kedro_datasets.video.VideoDataset
      • VideoDataset
        • VideoDataset.__init__()
        • VideoDataset.exists()
        • VideoDataset.from_config()
        • VideoDataset.load()
        • VideoDataset.release()
        • VideoDataset.save()
    • kedro_datasets.yaml.YAMLDataSet
      • YAMLDataSet
    • kedro_datasets.yaml.YAMLDataset
      • YAMLDataset
        • YAMLDataset.DEFAULT_SAVE_ARGS
        • YAMLDataset.__init__()
        • YAMLDataset.exists()
        • YAMLDataset.from_config()
        • YAMLDataset.load()
        • YAMLDataset.release()
        • YAMLDataset.resolve_load_version()
        • YAMLDataset.resolve_save_version()
        • YAMLDataset.save()
kedro
  • Docs »
  • Search
  • Edit on GitHub

Revision c3c93cb4.

Built with Sphinx using a theme provided by Read the Docs.