Flytekit SDK

These are the Flytekit SDK API docs.

Flytekit is the core Python SDK for the Union and Flyte platforms.

Developing on Flyte

For developing on the Flyte platform you need to add the flytekit package to your project:

$ uv add flytekit

This will install the Flytekit SDK and the pyflyte command-line tool.

When working with the FLytekit SDK you will be using the pyflyte CLI and the Flytekit SDK docs (not the Union SDK docs).

Developing on Union

For developing on the Union platform you need to add the union package to your project:

$ uv add union

This will install the Union SDK, which is a superset of the Flytekit SDK. It will also install the union command-line tool.

When working with the Union SDK you will be using the union CLI and both the Flytekit SDK and the Union SDK docs.

Directory

Classes

Class	Description
`flytekit.clients.auth.auth_client.AuthorizationClient`	Authorization client that stores the credentials in keyring and uses oauth2 standard flow to retrieve the credentials.
`flytekit.clients.auth.auth_client.AuthorizationCode`
`flytekit.clients.auth.auth_client.EndpointMetadata`	This class can be used to control the rendering of the page on login successful or failure.
`flytekit.clients.auth.auth_client.OAuthCallbackHandler`	A simple wrapper around BaseHTTPServer.BaseHTTPRequestHandler that handles a callback URL that accepts an authorization token.
`flytekit.clients.auth.auth_client.OAuthHTTPServer`	A simple wrapper around the BaseHTTPServer.HTTPServer implementation that binds an authorization_client for handling authorization code callbacks.
`flytekit.clients.auth.authenticator.Authenticator`	Base authenticator for all authentication flows.
`flytekit.clients.auth.authenticator.ClientConfig`	Client Configuration that is needed by the authenticator.
`flytekit.clients.auth.authenticator.ClientConfigStore`	Client Config store retrieve client config. this can be done in multiple ways.
`flytekit.clients.auth.authenticator.ClientCredentialsAuthenticator`	This Authenticator uses ClientId and ClientSecret to authenticate.
`flytekit.clients.auth.authenticator.CommandAuthenticator`	This Authenticator retrieves access_token using the provided command.
`flytekit.clients.auth.authenticator.DeviceCodeAuthenticator`	This Authenticator implements the Device Code authorization flow useful for headless user authentication.
`flytekit.clients.auth.authenticator.PKCEAuthenticator`	This Authenticator encapsulates the entire PKCE flow and automatically opens a browser window for login.
`flytekit.clients.auth.authenticator.StaticClientConfigStore`
`flytekit.clients.auth.exceptions.AccessTokenNotFoundError`	This error is raised with Access token is not found or if Refreshing the token fails.
`flytekit.clients.auth.exceptions.AuthenticationError`	This is raised for any AuthenticationError.
`flytekit.clients.auth.exceptions.AuthenticationPending`	This is raised if the token endpoint returns authentication pending.
`flytekit.clients.auth.keyring.Credentials`	Stores the credentials together.
`flytekit.clients.auth.keyring.KeyringStore`	Methods to access Keyring Store.
`flytekit.clients.auth.token_client.DeviceCodeResponse`	Response from device auth flow endpoint {‘device_code’: ‘code’, ‘user_code’: ‘BNDJJFXL’, ‘verification_uri’: ‘url’, ’expires_in’: 600, ‘interval’: 5}.
`flytekit.clients.auth.token_client.GrantType`
`flytekit.clients.auth_helper.AuthenticationHTTPAdapter`	A custom HTTPAdapter that adds authentication headers to requests of a session.
`flytekit.clients.auth_helper.RemoteClientConfigStore`	This class implements the ClientConfigStore that is served by the Flyte Server, that implements AuthMetadataService.
`flytekit.clients.friendly.SynchronousFlyteClient`	This is a low-level client that users can use to make direct gRPC service calls to the control plane.
`flytekit.clients.grpc_utils.auth_interceptor.AuthUnaryInterceptor`	This Interceptor can be used to automatically add Auth Metadata for every call - lazily in case authentication is needed.
`flytekit.clients.grpc_utils.deadline_interceptor.ScopedGrpcDeadlineInterceptor`	Applies the currently scoped gRPC timeout to unary-unary calls.
`flytekit.clients.grpc_utils.default_metadata_interceptor.DefaultMetadataInterceptor`
`flytekit.clients.grpc_utils.wrap_exception_interceptor.RetryExceptionWrapperInterceptor`
`flytekit.clients.raw.RawSynchronousFlyteClient`	This is a thin synchronous wrapper around the auto-generated GRPC stubs for communicating with the admin service.
`flytekit.clis.sdk_in_container.build.BuildCommand`	A click command group for building a image for flyte workflows & tasks in a file.
`flytekit.clis.sdk_in_container.build.BuildParams`
`flytekit.clis.sdk_in_container.build.BuildWorkflowCommand`	click multicommand at the python file layer, subcommands should be all the workflows in the file.
`flytekit.clis.sdk_in_container.run.DynamicEntityLaunchCommand`	This is a dynamic command that is created for each launch plan.
`flytekit.clis.sdk_in_container.run.Entities`	NamedTuple to group all entities in a file.
`flytekit.clis.sdk_in_container.run.RemoteEntityGroup`	click multicommand that retrieves launchplans from a remote flyte instance and executes them.
`flytekit.clis.sdk_in_container.run.RunCommand`	A click command group for registering and executing flyte workflows & tasks in a file.
`flytekit.clis.sdk_in_container.run.RunLevelComputedParams`	This class is used to store the computed parameters that are used to run a workflow / task / launchplan.
`flytekit.clis.sdk_in_container.run.RunLevelParams`	This class is used to store the parameters that are used to run a workflow / task / launchplan.
`flytekit.clis.sdk_in_container.run.WorkflowCommand`	click multicommand at the python file layer, subcommands should be all the workflows in the file.
`flytekit.clis.sdk_in_container.run.YamlFileReadingCommand`
`flytekit.clis.sdk_in_container.serialize.SerializationMode`
`flytekit.clis.sdk_in_container.utils.ErrorHandlingCommand`	Helper class that wraps the invoke method of a click command to catch exceptions and print them in a nice way.
`flytekit.clis.sdk_in_container.utils.PyFlyteParams`
`flytekit.configuration.AuthType`
`flytekit.configuration.AzureBlobStorageConfig`	Any Azure Blob Storage specific configuration.
`flytekit.configuration.Config`	This the parent configuration object and holds all the underlying configuration object types.
`flytekit.configuration.DataConfig`	Any data storage specific configuration.
`flytekit.configuration.EntrypointSettings`	This object carries information about the path of the entrypoint command that will be invoked at runtime.
`flytekit.configuration.FastSerializationSettings`	This object hold information about settings necessary to serialize an object so that it can be fast-registered.
`flytekit.configuration.GCSConfig`	Any GCS specific configuration.
`flytekit.configuration.GenericPersistenceConfig`	Data storage configuration that applies across any provider.
`flytekit.configuration.Image`	Image is a structured wrapper for task container images used in object serialization.
`flytekit.configuration.ImageConfig`	We recommend you to use ImageConfig.auto(img_name=None) to create an ImageConfig.
`flytekit.configuration.LocalConfig`	Any configuration specific to local runs.
`flytekit.configuration.PlatformConfig`	This object contains the settings to talk to a Flyte backend (the DNS location of your Admin server basically).
`flytekit.configuration.S3Config`	S3 specific configuration.
`flytekit.configuration.SecretsConfig`	Configuration for secrets.
`flytekit.configuration.SerializationSettings`	These settings are provided while serializing a workflow and task, before registration.
`flytekit.configuration.StatsConfig`	Configuration for sending statsd.
`flytekit.configuration.TaskConfig`	Any Project/Domain/Org configuration.
`flytekit.configuration.default_images.DefaultImages`	We may want to load the default images from remote - maybe s3 location etc?.
`flytekit.configuration.default_images.PythonVersion`
`flytekit.configuration.feature_flags.FeatureFlags`
`flytekit.configuration.file.ConfigEntry`	A top level Config entry holder, that holds multiple different representations of the config.
`flytekit.configuration.file.ConfigFile`
`flytekit.configuration.file.LegacyConfigEntry`	Creates a record for the config entry. contains.
`flytekit.configuration.file.YamlConfigEntry`	Creates a record for the config entry.
`flytekit.configuration.internal.AWS`
`flytekit.configuration.internal.AZURE`
`flytekit.configuration.internal.Credentials`
`flytekit.configuration.internal.GCP`
`flytekit.configuration.internal.Images`
`flytekit.configuration.internal.Local`
`flytekit.configuration.internal.LocalSDK`
`flytekit.configuration.internal.Persistence`
`flytekit.configuration.internal.Platform`
`flytekit.configuration.internal.Secrets`
`flytekit.configuration.internal.StatsD`
`flytekit.configuration.plugin.FlytekitPlugin`
`flytekit.constants.CopyFileDetection`
`flytekit.core.annotation.FlyteAnnotation`	A core object to add arbitrary annotations to flyte types.
`flytekit.core.array_node.ArrayNode`
`flytekit.core.array_node_map_task.ArrayNodeMapTask`
`flytekit.core.array_node_map_task.ArrayNodeMapTaskResolver`	Special resolver that is used for ArrayNodeMapTasks.
`flytekit.core.artifact.Artifact`	An Artifact is effectively just a metadata layer on top of data that exists in Flyte.
`flytekit.core.artifact.ArtifactIDSpecification`	This is a special object that helps specify how Artifacts are to be created.
`flytekit.core.artifact.ArtifactQuery`
`flytekit.core.artifact.DefaultArtifactSerializationHandler`
`flytekit.core.artifact.InputsBase`	A class to provide better partition semantics Used for invoking an Artifact to bind partition keys to input values.
`flytekit.core.artifact.Partition`
`flytekit.core.artifact.Partitions`
`flytekit.core.artifact.Serializer`
`flytekit.core.artifact.TimePartition`
`flytekit.core.base_sql_task.SQLTask`	Base task types for all SQL tasks.
`flytekit.core.base_task.IgnoreOutputs`	This exception should be used to indicate that the outputs generated by this can be safely ignored.
`flytekit.core.base_task.PythonTask`	Base Class for all Tasks with a Python native `Interface`.
`flytekit.core.base_task.Task`	The base of all Tasks in flytekit.
`flytekit.core.base_task.TaskMetadata`	Metadata for a Task.
`flytekit.core.base_task.TaskResolverMixin`	Flytekit tasks interact with the Flyte platform very, very broadly in two steps.
`flytekit.core.cache.Cache`	Cache configuration for a task.
`flytekit.core.cache.VersionParameters`	Parameters used for version hash generation.
`flytekit.core.checkpointer.Checkpoint`	Base class for Checkpoint system.
`flytekit.core.checkpointer.SyncCheckpoint`	This class is NOT THREAD-SAFE!
`flytekit.core.class_based_resolver.ClassStorageTaskResolver`	Stores tasks inside a class variable.
`flytekit.core.condition.BranchNode`
`flytekit.core.condition.Case`
`flytekit.core.condition.Condition`
`flytekit.core.condition.ConditionalSection`	ConditionalSection is used to denote a condition within a Workflow.
`flytekit.core.condition.LocalExecutedConditionalSection`
`flytekit.core.condition.SkippedConditionalSection`	This ConditionalSection is used for nested conditionals, when the branch has been evaluated to false.
`flytekit.core.container_task.ContainerTask`	This is an intermediate class that represents Flyte Tasks that run a container at execution time.
`flytekit.core.context_manager.BranchEvalMode`	This is a 3-way class, with the None value meaning that we are not within a conditional context.
`flytekit.core.context_manager.CompilationState`	Compilation state is used during the compilation of a workflow or task.
`flytekit.core.context_manager.ExecutionParameters`	This is a run-time user-centric context object that is accessible to every @task method.
`flytekit.core.context_manager.ExecutionState`	This is the context that is active when executing a task or a local workflow.
`flytekit.core.context_manager.FlyteContext`	This is an internal-facing context object, that most users will not have to deal with.
`flytekit.core.context_manager.FlyteContextManager`	FlyteContextManager manages the execution context within Flytekit.
`flytekit.core.context_manager.FlyteEntities`	This is a global Object that tracks various tasks and workflows that are declared within a VM during the registration process.
`flytekit.core.context_manager.OutputMetadata`
`flytekit.core.context_manager.OutputMetadataTracker`	This class is for the users to set arbitrary metadata on output literals.
`flytekit.core.context_manager.SecretsManager`	This provides a secrets resolution logic at runtime.
`flytekit.core.data_persistence.FileAccessProvider`	This is the class that is available through the FlyteContext and can be used for persisting data to the remote durable store.
`flytekit.core.docstring.Docstring`
`flytekit.core.environment.Environment`
`flytekit.core.gate.Gate`	A node type that waits for user input before proceeding with a workflow.
`flytekit.core.hash.HashMethod`	Flyte-specific object used to wrap the hash function for a specific type.
`flytekit.core.hash.HashOnReferenceMixin`
`flytekit.core.interface.Interface`	A Python native interface object, like inspect.signature but simpler.
`flytekit.core.launch_plan.LaunchPlan`	Launch Plans are one of the core constructs of Flyte.
`flytekit.core.launch_plan.ReferenceLaunchPlan`	A reference launch plan serves as a pointer to a Launch Plan that already exists on your Flyte installation.
`flytekit.core.legacy_map_task.MapPythonTask`	A MapPythonTask defines a `flytekit.PythonTask` which specifies how to run an inner `flytekit.PythonFunctionTask` across a range of inputs in parallel.
`flytekit.core.legacy_map_task.MapTaskResolver`	Special resolver that is used for MapTasks.
`flytekit.core.local_cache.LocalTaskCache`	This class implements a persistent store able to cache the result of local task executions.
`flytekit.core.local_fsspec.FlyteLocalFileSystem`	This class doesn’t do anything except override the separator so that it works on windows.
`flytekit.core.mock_stats.MockStats`
`flytekit.core.node.Node`	This class will hold all the things necessary to make an SdkNode but we won’t make one until we know things like.
`flytekit.core.notification.Email`	This notification should be used when sending regular emails to people.
`flytekit.core.notification.Notification`
`flytekit.core.notification.PagerDuty`	This notification should be used when sending emails to the PagerDuty service.
`flytekit.core.notification.Slack`	This notification should be used when sending emails to the Slack.
`flytekit.core.options.Options`	These are options that can be configured for a launchplan during registration or overridden during an execution.
`flytekit.core.pod_template.PodTemplate`	Custom PodTemplate specification for a Task.
`flytekit.core.promise.ComparisonExpression`	ComparisonExpression refers to an expression of the form (lhs operator rhs), where lhs and rhs are operands and operator can be any comparison expression like <, >, <=, >=, ==, !=.
`flytekit.core.promise.ComparisonOps`
`flytekit.core.promise.ConjunctionExpression`	A Conjunction Expression is an expression of the form either (A and B) or (A or B). where A, B are two expressions (comparison or conjunctions) and (and, or) are logical truth operators.
`flytekit.core.promise.ConjunctionOps`
`flytekit.core.promise.NodeOutput`
`flytekit.core.promise.Promise`	This object is a wrapper and exists for three main reasons.
`flytekit.core.promise.VoidPromise`	This object is returned for tasks that do not return any outputs (declared interface is empty).
`flytekit.core.python_auto_container.DefaultNotebookTaskResolver`	This resolved is used when the task is defined in a notebook.
`flytekit.core.python_auto_container.DefaultTaskResolver`	Please see the notes in the TaskResolverMixin as it describes this default behavior.
`flytekit.core.python_auto_container.PickledEntity`	Represents the structure of the pickled object stored in the .pkl file for interactive mode.
`flytekit.core.python_auto_container.PickledEntityMetadata`	Metadata for a pickled entity containing version information.
`flytekit.core.python_auto_container.PythonAutoContainerTask`	A Python AutoContainer task should be used as the base for all extensions that want the user’s code to be in the container and the container information to be automatically captured.
`flytekit.core.python_customized_container_task.PythonCustomizedContainerTask`	Please take a look at the comments for `flytekit.extend.ExecutableTemplateShimTask` as well.
`flytekit.core.python_customized_container_task.TaskTemplateResolver`	This is a special resolver that resolves the task above at execution time, using only the `TaskTemplate`, meaning it should only be used for tasks that contain all pertinent information within the template itself.
`flytekit.core.python_function_task.AsyncPythonFunctionTask`	This is the base task for eager tasks, as well as normal async tasks Really only need to override the call function.
`flytekit.core.python_function_task.EagerAsyncPythonFunctionTask`	This is the base eager task (aka eager workflow) type.
`flytekit.core.python_function_task.EagerFailureHandlerTask`
`flytekit.core.python_function_task.EagerFailureTaskResolver`
`flytekit.core.python_function_task.PythonFunctionTask`	A Python Function task should be used as the base for all extensions that have a python function.
`flytekit.core.python_function_task.PythonInstanceTask`	This class should be used as the base class for all Tasks that do not have a user defined function body, but have a platform defined execute method.
`flytekit.core.reference_entity.LaunchPlanReference`	A reference object containing metadata that points to a remote launch plan.
`flytekit.core.reference_entity.Reference`
`flytekit.core.reference_entity.ReferenceEntity`
`flytekit.core.reference_entity.ReferenceSpec`
`flytekit.core.reference_entity.ReferenceTemplate`
`flytekit.core.reference_entity.TaskReference`	A reference object containing metadata that points to a remote task.
`flytekit.core.reference_entity.WorkflowReference`	A reference object containing metadata that points to a remote workflow.
`flytekit.core.resources.ResourceSpec`
`flytekit.core.resources.Resources`	This class is used to specify both resource requests and resource limits.
`flytekit.core.schedule.CronSchedule`	Use this when you have a launch plan that you want to run on a cron expression.
`flytekit.core.schedule.FixedRate`	Use this class to schedule a fixed-rate interval for a launch plan.
`flytekit.core.schedule.OnSchedule`
`flytekit.core.shim_task.ExecutableTemplateShimTask`	The canonical `@task` decorated Python function task is pretty simple to reason about.
`flytekit.core.shim_task.ShimTaskExecutor`
`flytekit.core.task.Echo`
`flytekit.core.task.ReferenceTask`	This is a reference task, the body of the function passed in through the constructor will never be used, only the signature of the function will be.
`flytekit.core.task.TaskPlugins`	This is the TaskPlugins factory for task types that are derivative of PythonFunctionTask.
`flytekit.core.tracked_abc.FlyteTrackedABC`	This class exists because if you try to inherit from abc.ABC and TrackedInstance by itself, you’ll get the well-known `TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases` error.
`flytekit.core.tracker.InstanceTrackingMeta`	Please see the original class :flytekit.common.mixins.registerable._InstanceTracker` also and also look at the tests in the `tests/flytekit/unit/core/tracker/test_tracking/` folder to see how it’s used.
`flytekit.core.tracker.TrackedInstance`	Please see the notes for the metaclass above first.
`flytekit.core.type_engine.AsyncTypeTransformer`
`flytekit.core.type_engine.BatchSize`	This is used to annotate a FlyteDirectory when we want to download/upload the contents of the directory in batches.
`flytekit.core.type_engine.BinaryIOTransformer`	Handler for BinaryIO.
`flytekit.core.type_engine.DataclassTransformer`	The Dataclass Transformer provides a type transformer for dataclasses.
`flytekit.core.type_engine.DictTransformer`	Transformer that transforms an univariate dictionary Dict[str, T] to a Literal Map or transforms an untyped dictionary to a Binary Scalar Literal with a Struct Literal Type.
`flytekit.core.type_engine.EnumTransformer`	Enables converting a python type enum.Enum to LiteralType.EnumType.
`flytekit.core.type_engine.ListTransformer`	Transformer that handles a univariate typing.List[T].
`flytekit.core.type_engine.LiteralTypeTransformer`
`flytekit.core.type_engine.LiteralsResolver`	LiteralsResolver is a helper class meant primarily for use with the FlyteRemote experience or any other situation where you might be working with LiteralMaps.
`flytekit.core.type_engine.ProtobufTransformer`
`flytekit.core.type_engine.RestrictedTypeError`
`flytekit.core.type_engine.RestrictedTypeTransformer`	Types registered with the RestrictedTypeTransformer are not allowed to be converted to and from literals.
`flytekit.core.type_engine.SimpleTransformer`	A Simple implementation of a type transformer that uses simple lambdas to transform and reduces boilerplate.
`flytekit.core.type_engine.TextIOTransformer`	Handler for TextIO.
`flytekit.core.type_engine.TypeEngine`	Core Extensible TypeEngine of Flytekit.
`flytekit.core.type_engine.TypeTransformer`	Base transformer type that should be implemented for every python native type that can be handled by flytekit.
`flytekit.core.type_engine.TypeTransformerFailedError`
`flytekit.core.type_engine.UnionTransformer`	Transformer that handles a typing.Union[T1, T2, …]
`flytekit.core.utils.AutoDeletingTempDir`	Creates a posix safe tempdir which is auto deleted once out of scope.
`flytekit.core.utils.ClassDecorator`	Abstract class for class decorators.
`flytekit.core.utils.Directory`
`flytekit.core.utils.timeit`	A context manager and a decorator that measures the execution time of the wrapped code block or functions.
`flytekit.core.worker_queue.Controller`	This controller object is responsible for kicking off and monitoring executions against a Flyte Admin endpoint using a FlyteRemote object.
`flytekit.core.worker_queue.ItemStatus`
`flytekit.core.worker_queue.Update`
`flytekit.core.worker_queue.WorkItem`	This is a class to keep track of what the user requested.
`flytekit.core.workflow.ImperativeWorkflow`	An imperative workflow is a programmatic analogue to the typical `@workflow` function-based workflow and is better suited to programmatic applications.
`flytekit.core.workflow.PythonFunctionWorkflow`	Please read `flyte:divedeep-workflows` first for a high-level understanding of what workflows are in Flyte.
`flytekit.core.workflow.ReferenceWorkflow`	A reference workflow is a pointer to a workflow that already exists on your Flyte installation.
`flytekit.core.workflow.WorkflowBase`
`flytekit.core.workflow.WorkflowFailurePolicy`	Defines the behavior for a workflow execution in the case of an observed node execution failure.
`flytekit.core.workflow.WorkflowMetadata`
`flytekit.core.workflow.WorkflowMetadataDefaults`	This class is similarly named to the one above.
`flytekit.deck.deck.Deck`	Deck enable users to get customizable and default visibility into their tasks.
`flytekit.deck.deck.DeckField`	DeckField is used to specify the fields that will be rendered in the deck.
`flytekit.deck.deck.TimeLineDeck`	The TimeLineDeck class is designed to render the execution time of each part of a task.
`flytekit.deck.renderer.ArrowRenderer`	Render an Arrow dataframe as an HTML table.
`flytekit.deck.renderer.MarkdownRenderer`	Convert a markdown string to HTML and return HTML as a unicode string.
`flytekit.deck.renderer.PythonDependencyRenderer`	PythonDependencyDeck is a deck that contains information about packages installed via pip.
`flytekit.deck.renderer.SourceCodeRenderer`	Convert Python source code to HTML, and return HTML as a unicode string.
`flytekit.deck.renderer.TopFrameRenderer`	Render a DataFrame as an HTML table.
`flytekit.exceptions.base.FlyteException`
`flytekit.exceptions.base.FlyteRecoverableException`
`flytekit.exceptions.eager.EagerException`	Raised when a node in an eager workflow encounters an error.
`flytekit.exceptions.scopes.FlyteScopedException`
`flytekit.exceptions.scopes.FlyteScopedSystemException`
`flytekit.exceptions.scopes.FlyteScopedUserException`
`flytekit.exceptions.system.FlyteAgentNotFound`
`flytekit.exceptions.system.FlyteConnectorNotFound`
`flytekit.exceptions.system.FlyteDownloadDataException`
`flytekit.exceptions.system.FlyteEntrypointNotLoadable`
`flytekit.exceptions.system.FlyteNonRecoverableSystemException`
`flytekit.exceptions.system.FlyteNotImplementedException`
`flytekit.exceptions.system.FlyteSystemAssertion`
`flytekit.exceptions.system.FlyteSystemException`
`flytekit.exceptions.system.FlyteSystemUnavailableException`
`flytekit.exceptions.system.FlyteUploadDataException`
`flytekit.exceptions.user.FlyteAssertion`
`flytekit.exceptions.user.FlyteAuthenticationException`
`flytekit.exceptions.user.FlyteCompilationException`
`flytekit.exceptions.user.FlyteDataNotFoundException`
`flytekit.exceptions.user.FlyteDisapprovalException`
`flytekit.exceptions.user.FlyteEntityAlreadyExistsException`
`flytekit.exceptions.user.FlyteEntityNotExistException`
`flytekit.exceptions.user.FlyteEntityNotFoundException`
`flytekit.exceptions.user.FlyteFailureNodeInputMismatchException`
`flytekit.exceptions.user.FlyteInvalidInputException`
`flytekit.exceptions.user.FlyteMissingReturnValueException`
`flytekit.exceptions.user.FlyteMissingTypeException`
`flytekit.exceptions.user.FlytePromiseAttributeResolveException`
`flytekit.exceptions.user.FlyteRecoverableException`
`flytekit.exceptions.user.FlyteTimeout`
`flytekit.exceptions.user.FlyteTypeException`
`flytekit.exceptions.user.FlyteUserException`
`flytekit.exceptions.user.FlyteUserRuntimeException`
`flytekit.exceptions.user.FlyteValidationException`
`flytekit.exceptions.user.FlyteValueException`
`flytekit.extend.backend.base_connector.AsyncConnectorBase`	This is the base class for all async connectors.
`flytekit.extend.backend.base_connector.AsyncConnectorExecutorMixin`	This mixin class is used to run the async task locally, and it’s only used for local execution.
`flytekit.extend.backend.base_connector.ConnectorBase`
`flytekit.extend.backend.base_connector.ConnectorRegistry`	This is the registry for all connectors.
`flytekit.extend.backend.base_connector.Resource`	This is the output resource of the job.
`flytekit.extend.backend.base_connector.ResourceMeta`	This is the metadata for the job.
`flytekit.extend.backend.base_connector.SyncConnectorBase`	This is the base class for all sync connectors.
`flytekit.extend.backend.base_connector.SyncConnectorExecutorMixin`	This mixin class is used to run the sync task locally, and it’s only used for local execution.
`flytekit.extend.backend.base_connector.TaskCategory`
`flytekit.extend.backend.connector_service.AsyncConnectorService`
`flytekit.extend.backend.connector_service.ConnectorMetadataService`
`flytekit.extend.backend.connector_service.SyncConnectorService`
`flytekit.extras.accelerators.BaseAccelerator`	Base class for all accelerator types.
`flytekit.extras.accelerators.GPUAccelerator`	Class that represents a GPU accelerator.
`flytekit.extras.accelerators.MultiInstanceGPUAccelerator`	Base class for all multi-instance GPU accelerator types.
`flytekit.extras.cloud_pickle_resolver.ExperimentalNaiveCloudPickleResolver`	Please do not use this resolver, basically ever.
`flytekit.extras.pydantic_transformer.transformer.PydanticTransformer`
`flytekit.extras.sklearn.native.SklearnEstimatorTransformer`
`flytekit.extras.sklearn.native.SklearnTypeTransformer`
`flytekit.extras.sqlite3.task.SQLite3Config`	Use this configuration to configure if sqlite3 files that should be loaded by the task.
`flytekit.extras.sqlite3.task.SQLite3Task`	Run client side SQLite3 queries that optionally return a FlyteSchema object.
`flytekit.extras.sqlite3.task.SQLite3TaskExecutor`
`flytekit.extras.tasks.shell.AttrDict`	Convert a dictionary to an attribute style lookup.
`flytekit.extras.tasks.shell.OutputLocation`
`flytekit.extras.tasks.shell.ProcessResult`	Stores a process return code, standard output and standard error.
`flytekit.extras.tasks.shell.RawShellTask`
`flytekit.extras.tasks.shell.ShellTask`
`flytekit.extras.webhook.WebhookConnector`	WebhookConnector is responsible for handling webhook tasks.
`flytekit.extras.webhook.WebhookTask`	The WebhookTask is used to invoke a webhook.
`flytekit.extras.webhook.connector.WebhookConnector`	WebhookConnector is responsible for handling webhook tasks.
`flytekit.extras.webhook.task.WebhookTask`	The WebhookTask is used to invoke a webhook.
`flytekit.image_spec.default_builder.DefaultImageBuilder`	Image builder using Docker and buildkit.
`flytekit.image_spec.image_spec.ImageBuildEngine`	ImageBuildEngine contains a list of builders that can be used to build an ImageSpec.
`flytekit.image_spec.image_spec.ImageSpec`	This class is used to specify the docker image that will be used to run the task.
`flytekit.image_spec.image_spec.ImageSpecBuilder`
`flytekit.image_spec.noop_builder.NoOpBuilder`	Noop image builder.
`flytekit.interaction.click_types.DateTimeType`
`flytekit.interaction.click_types.DirParamType`
`flytekit.interaction.click_types.DurationParamType`
`flytekit.interaction.click_types.EnumParamType`
`flytekit.interaction.click_types.FileParamType`
`flytekit.interaction.click_types.FlyteLiteralConverter`
`flytekit.interaction.click_types.JSONIteratorParamType`
`flytekit.interaction.click_types.JsonParamType`
`flytekit.interaction.click_types.PickleParamType`
`flytekit.interaction.click_types.StructuredDatasetParamType`	TODO handle column types.
`flytekit.interaction.click_types.UnionParamType`	A composite type that allows for multiple types to be specified.
`flytekit.interaction.rich_utils.RichCallback`
`flytekit.interactive.vscode_lib.config.VscodeConfig`	VscodeConfig is the config contains default URLs of the VSCode server and extension remote paths.
`flytekit.interactive.vscode_lib.decorator.vscode`
`flytekit.interfaces.cli_identifiers.Identifier`
`flytekit.interfaces.cli_identifiers.TaskExecutionIdentifier`
`flytekit.interfaces.cli_identifiers.WorkflowExecutionIdentifier`
`flytekit.interfaces.stats.client.DummyStatsClient`	A dummy client for statsd.
`flytekit.interfaces.stats.client.ScopeableStatsProxy`	A Proxy object for an underlying statsd client.
`flytekit.interfaces.stats.client.StatsClientProxy`
`flytekit.interfaces.stats.taggable.TaggableStats`
`flytekit.models.admin.common.Sort`
`flytekit.models.admin.task_execution.TaskExecution`
`flytekit.models.admin.task_execution.TaskExecutionClosure`
`flytekit.models.admin.workflow.Workflow`
`flytekit.models.admin.workflow.WorkflowClosure`
`flytekit.models.admin.workflow.WorkflowSpec`
`flytekit.models.annotation.TypeAnnotation`	Python class representation of the flyteidl TypeAnnotation message.
`flytekit.models.array_job.ArrayJob`
`flytekit.models.common.Annotations`
`flytekit.models.common.AuthRole`
`flytekit.models.common.EmailNotification`
`flytekit.models.common.Envs`
`flytekit.models.common.FlyteABCMeta`
`flytekit.models.common.FlyteCustomIdlEntity`
`flytekit.models.common.FlyteIdlEntity`
`flytekit.models.common.FlyteType`
`flytekit.models.common.Labels`
`flytekit.models.common.NamedEntityIdentifier`
`flytekit.models.common.Notification`
`flytekit.models.common.PagerDutyNotification`
`flytekit.models.common.RawOutputDataConfig`
`flytekit.models.common.SlackNotification`
`flytekit.models.common.UrlBlob`
`flytekit.models.concurrency.ConcurrencyLimitBehavior`
`flytekit.models.concurrency.ConcurrencyPolicy`	Defines the concurrency policy for a launch plan.
`flytekit.models.core.catalog.CatalogArtifactTag`
`flytekit.models.core.catalog.CatalogMetadata`
`flytekit.models.core.compiler.CompiledTask`
`flytekit.models.core.compiler.CompiledWorkflow`
`flytekit.models.core.compiler.CompiledWorkflowClosure`
`flytekit.models.core.compiler.ConnectionSet`
`flytekit.models.core.condition.BooleanExpression`
`flytekit.models.core.condition.ComparisonExpression`
`flytekit.models.core.condition.ConjunctionExpression`
`flytekit.models.core.condition.Operand`
`flytekit.models.core.errors.ContainerError`
`flytekit.models.core.errors.ErrorDocument`
`flytekit.models.core.execution.ExecutionError`
`flytekit.models.core.execution.NodeExecutionPhase`
`flytekit.models.core.execution.TaskExecutionPhase`
`flytekit.models.core.execution.TaskLog`
`flytekit.models.core.execution.WorkflowExecutionPhase`	This class holds enum values used for setting notifications.
`flytekit.models.core.identifier.Identifier`
`flytekit.models.core.identifier.NodeExecutionIdentifier`
`flytekit.models.core.identifier.ResourceType`
`flytekit.models.core.identifier.SignalIdentifier`
`flytekit.models.core.identifier.TaskExecutionIdentifier`
`flytekit.models.core.identifier.WorkflowExecutionIdentifier`
`flytekit.models.core.types.BlobType`	This type represents offloaded data and is typically used for things like files.
`flytekit.models.core.types.EnumType`	Models _types_pb2.EnumType.
`flytekit.models.core.workflow.Alias`
`flytekit.models.core.workflow.ApproveCondition`
`flytekit.models.core.workflow.ArrayNode`
`flytekit.models.core.workflow.BranchNode`
`flytekit.models.core.workflow.GateNode`
`flytekit.models.core.workflow.IfBlock`
`flytekit.models.core.workflow.IfElseBlock`
`flytekit.models.core.workflow.Node`
`flytekit.models.core.workflow.NodeMetadata`
`flytekit.models.core.workflow.SignalCondition`
`flytekit.models.core.workflow.SleepCondition`
`flytekit.models.core.workflow.TaskNode`
`flytekit.models.core.workflow.TaskNodeOverrides`
`flytekit.models.core.workflow.WorkflowMetadata`
`flytekit.models.core.workflow.WorkflowMetadataDefaults`
`flytekit.models.core.workflow.WorkflowNode`
`flytekit.models.core.workflow.WorkflowTemplate`
`flytekit.models.documentation.Description`	Full user description with formatting preserved.
`flytekit.models.documentation.Documentation`	DescriptionEntity contains detailed description for the task/workflow/launch plan.
`flytekit.models.documentation.SourceCode`	Link to source code used to define this task or workflow.
`flytekit.models.domain.Domain`	Domains are fixed and unique at the global level, and provide an abstraction to isolate resources and feature configuration for different deployment environments.
`flytekit.models.dynamic_job.DynamicJobSpec`
`flytekit.models.event.TaskExecutionMetadata`
`flytekit.models.execution.AbortMetadata`
`flytekit.models.execution.ClusterAssignment`
`flytekit.models.execution.Execution`
`flytekit.models.execution.ExecutionClosure`
`flytekit.models.execution.ExecutionMetadata`
`flytekit.models.execution.ExecutionSpec`
`flytekit.models.execution.LiteralMapBlob`
`flytekit.models.execution.NodeExecutionGetDataResponse`
`flytekit.models.execution.NotificationList`
`flytekit.models.execution.SystemMetadata`
`flytekit.models.execution.TaskExecutionGetDataResponse`
`flytekit.models.execution.WorkflowExecutionGetDataResponse`
`flytekit.models.filters.Contains`
`flytekit.models.filters.Equal`
`flytekit.models.filters.Filter`
`flytekit.models.filters.FilterList`
`flytekit.models.filters.GreaterThan`
`flytekit.models.filters.GreaterThanOrEqual`
`flytekit.models.filters.LessThan`
`flytekit.models.filters.LessThanOrEqual`
`flytekit.models.filters.NotEqual`
`flytekit.models.filters.SetFilter`
`flytekit.models.filters.ValueIn`
`flytekit.models.filters.ValueNotIn`
`flytekit.models.interface.Parameter`
`flytekit.models.interface.ParameterMap`
`flytekit.models.interface.TypedInterface`
`flytekit.models.interface.Variable`
`flytekit.models.interface.VariableMap`
`flytekit.models.launch_plan.Auth`
`flytekit.models.launch_plan.LaunchPlan`
`flytekit.models.launch_plan.LaunchPlanClosure`
`flytekit.models.launch_plan.LaunchPlanMetadata`
`flytekit.models.launch_plan.LaunchPlanSpec`
`flytekit.models.launch_plan.LaunchPlanState`
`flytekit.models.literals.Binary`
`flytekit.models.literals.Binding`
`flytekit.models.literals.BindingData`
`flytekit.models.literals.BindingDataCollection`
`flytekit.models.literals.BindingDataMap`
`flytekit.models.literals.Blob`
`flytekit.models.literals.BlobMetadata`	This is metadata for the Blob literal.
`flytekit.models.literals.Literal`
`flytekit.models.literals.LiteralCollection`
`flytekit.models.literals.LiteralMap`
`flytekit.models.literals.LiteralOffloadedMetadata`
`flytekit.models.literals.Primitive`
`flytekit.models.literals.RetryStrategy`
`flytekit.models.literals.Scalar`
`flytekit.models.literals.Schema`
`flytekit.models.literals.StructuredDataset`
`flytekit.models.literals.StructuredDatasetMetadata`
`flytekit.models.literals.Union`
`flytekit.models.literals.Void`
`flytekit.models.matchable_resource.ClusterResourceAttributes`
`flytekit.models.matchable_resource.ExecutionClusterLabel`
`flytekit.models.matchable_resource.ExecutionQueueAttributes`
`flytekit.models.matchable_resource.MatchableResource`
`flytekit.models.matchable_resource.MatchingAttributes`
`flytekit.models.matchable_resource.PluginOverride`
`flytekit.models.matchable_resource.PluginOverrides`
`flytekit.models.named_entity.NamedEntityIdentifier`
`flytekit.models.named_entity.NamedEntityMetadata`
`flytekit.models.named_entity.NamedEntityState`
`flytekit.models.node_execution.DynamicWorkflowNodeMetadata`
`flytekit.models.node_execution.NodeExecution`
`flytekit.models.node_execution.NodeExecutionClosure`
`flytekit.models.node_execution.TaskNodeMetadata`
`flytekit.models.node_execution.WorkflowNodeMetadata`
`flytekit.models.presto.PrestoQuery`
`flytekit.models.project.Project`
`flytekit.models.qubole.HiveQuery`
`flytekit.models.qubole.HiveQueryCollection`
`flytekit.models.qubole.QuboleHiveJob`
`flytekit.models.schedule.Schedule`
`flytekit.models.security.Identity`
`flytekit.models.security.OAuth2Client`
`flytekit.models.security.OAuth2TokenRequest`
`flytekit.models.security.Secret`	See `cookbook:secrets` for usage examples.
`flytekit.models.security.SecurityContext`	This is a higher level wrapper object that for the most part users shouldn’t have to worry about.
`flytekit.models.task.CompiledTask`
`flytekit.models.task.Container`
`flytekit.models.task.DataLoadingConfig`
`flytekit.models.task.IOStrategy`	Provides methods to manage data in and out of the Raw container using Download Modes.
`flytekit.models.task.K8sObjectMetadata`
`flytekit.models.task.K8sPod`
`flytekit.models.task.Resources`
`flytekit.models.task.RuntimeMetadata`
`flytekit.models.task.Sql`
`flytekit.models.task.Task`
`flytekit.models.task.TaskClosure`
`flytekit.models.task.TaskExecutionMetadata`
`flytekit.models.task.TaskMetadata`
`flytekit.models.task.TaskSpec`
`flytekit.models.task.TaskTemplate`
`flytekit.models.types.Error`
`flytekit.models.types.LiteralType`
`flytekit.models.types.OutputReference`
`flytekit.models.types.SchemaType`
`flytekit.models.types.SimpleType`
`flytekit.models.types.StructuredDatasetType`
`flytekit.models.types.TypeStructure`	Models _types_pb2.TypeStructure.
`flytekit.models.types.UnionType`	Models _types_pb2.UnionType.
`flytekit.models.workflow_closure.WorkflowClosure`
`flytekit.remote.entities.FlyteArrayNode`
`flytekit.remote.entities.FlyteBranchNode`
`flytekit.remote.entities.FlyteGateNode`
`flytekit.remote.entities.FlyteLaunchPlan`	A class encapsulating a remote Flyte launch plan.
`flytekit.remote.entities.FlyteNode`	A class encapsulating a remote Flyte node.
`flytekit.remote.entities.FlyteTask`	A class encapsulating a remote Flyte task.
`flytekit.remote.entities.FlyteTaskNode`	A class encapsulating a task that a Flyte node needs to execute.
`flytekit.remote.entities.FlyteWorkflow`	A class encapsulating a remote Flyte workflow.
`flytekit.remote.entities.FlyteWorkflowNode`	A class encapsulating a workflow that a Flyte node needs to execute.
`flytekit.remote.executions.FlyteNodeExecution`	A class encapsulating a node execution being run on a Flyte remote backend.
`flytekit.remote.executions.FlyteTaskExecution`	A class encapsulating a task execution being run on a Flyte remote backend.
`flytekit.remote.executions.FlyteWorkflowExecution`	A class encapsulating a workflow execution being run on a Flyte remote backend.
`flytekit.remote.executions.RemoteExecutionBase`
`flytekit.remote.interface.TypedInterface`
`flytekit.remote.lazy_entity.LazyEntity`	Fetches the entity when the entity is called or when the entity is retrieved.
`flytekit.remote.metrics.FlyteExecutionSpan`
`flytekit.remote.remote.FlyteRemote`	Main entrypoint for programmatically accessing a Flyte remote backend.
`flytekit.remote.remote.RegistrationSkipped`	RegistrationSkipped error is raised when trying to register an entity that is not registrable.
`flytekit.remote.remote.ResolvedIdentifiers`
`flytekit.remote.remote_callable.RemoteEntity`
`flytekit.remote.remote_fs.FlyteFS`	Want this to behave mostly just like the HTTP file system.
`flytekit.remote.remote_fs.FlytePathResolver`
`flytekit.remote.remote_fs.HttpFileWriter`
`flytekit.sensor.base_sensor.BaseSensor`	Base class for all sensors.
`flytekit.sensor.base_sensor.SensorMetadata`
`flytekit.sensor.file_sensor.FileSensor`
`flytekit.sensor.sensor_engine.SensorEngine`
`flytekit.tools.fast_registration.FastPackageOptions`	FastPackageOptions is used to set configuration options when packaging files.
`flytekit.tools.ignore.DockerIgnore`	Uses docker-py’s PatternMatcher to check whether a path is ignored.
`flytekit.tools.ignore.FlyteIgnore`	Uses a .flyteignore file to determine ignored files.
`flytekit.tools.ignore.GitIgnore`	Uses git cli (if available) to list all ignored files and compare with those.
`flytekit.tools.ignore.Ignore`	Base for Ignores, implements core logic.
`flytekit.tools.ignore.IgnoreGroup`	Groups multiple Ignores and checks a path against them.
`flytekit.tools.ignore.StandardIgnore`	Retains the standard ignore functionality that previously existed.
`flytekit.tools.repo.NoSerializableEntitiesError`
`flytekit.types.directory.types.FlyteDirToMultipartBlobTransformer`	This transformer handles conversion between the Python native FlyteDirectory class defined above, and the Flyte IDL literal/type of Multipart Blob.
`flytekit.types.directory.types.FlyteDirectory`
`flytekit.types.error.error.ErrorTransformer`	Enables converting a python type FlyteError to LiteralType.Error.
`flytekit.types.error.error.FlyteError`	Special Task type that will be used in the failure node.
`flytekit.types.file.FileExt`	Used for annotating file extension types of FlyteFile.
`flytekit.types.file.file.FlyteFile`
`flytekit.types.file.file.FlyteFilePathTransformer`
`flytekit.types.file.image.PILImageTransformer`	TypeTransformer that supports PIL.Image as a native type.
`flytekit.types.iterator.iterator.FlyteIterator`
`flytekit.types.iterator.iterator.IteratorTransformer`
`flytekit.types.iterator.json_iterator.JSONIterator`
`flytekit.types.iterator.json_iterator.JSONIteratorTransformer`	A JSON iterator that handles conversion between an iterator/generator and a JSONL file.
`flytekit.types.numpy.ndarray.NumpyArrayTransformer`	TypeTransformer that supports np.ndarray as a native type.
`flytekit.types.pickle.pickle.FlytePickle`	This type is only used by flytekit internally.
`flytekit.types.pickle.pickle.FlytePickleTransformer`
`flytekit.types.schema.types.FlyteSchema`
`flytekit.types.schema.types.FlyteSchemaTransformer`
`flytekit.types.schema.types.LocalIOSchemaReader`
`flytekit.types.schema.types.LocalIOSchemaWriter`
`flytekit.types.schema.types.SchemaEngine`	This is the core Engine that handles all schema sub-systems.
`flytekit.types.schema.types.SchemaFormat`	Represents the schema storage format (at rest).
`flytekit.types.schema.types.SchemaHandler`
`flytekit.types.schema.types.SchemaOpenMode`
`flytekit.types.schema.types.SchemaReader`	Base SchemaReader to handle any readers (that can manage their own IO or otherwise).
`flytekit.types.schema.types.SchemaWriter`
`flytekit.types.schema.types_pandas.PandasDataFrameTransformer`	Transforms a pd.DataFrame to Schema without column types.
`flytekit.types.schema.types_pandas.PandasSchemaReader`
`flytekit.types.schema.types_pandas.PandasSchemaWriter`
`flytekit.types.schema.types_pandas.ParquetIO`
`flytekit.types.structured.basic_dfs.ArrowToParquetEncodingHandler`
`flytekit.types.structured.basic_dfs.CSVToPandasDecodingHandler`
`flytekit.types.structured.basic_dfs.PandasToCSVEncodingHandler`
`flytekit.types.structured.basic_dfs.PandasToParquetEncodingHandler`
`flytekit.types.structured.basic_dfs.ParquetToArrowDecodingHandler`
`flytekit.types.structured.basic_dfs.ParquetToPandasDecodingHandler`
`flytekit.types.structured.bigquery.ArrowToBQEncodingHandlers`
`flytekit.types.structured.bigquery.BQToArrowDecodingHandler`
`flytekit.types.structured.bigquery.BQToPandasDecodingHandler`
`flytekit.types.structured.bigquery.PandasToBQEncodingHandlers`
`flytekit.types.structured.snowflake.PandasToSnowflakeEncodingHandlers`
`flytekit.types.structured.snowflake.SnowflakeToPandasDecodingHandler`
`flytekit.types.structured.structured_dataset.DuplicateHandlerError`
`flytekit.types.structured.structured_dataset.StructuredDataset`	This is the user facing StructuredDataset class.
`flytekit.types.structured.structured_dataset.StructuredDatasetDecoder`
`flytekit.types.structured.structured_dataset.StructuredDatasetEncoder`
`flytekit.types.structured.structured_dataset.StructuredDatasetTransformerEngine`	Think of this transformer as a higher-level meta transformer that is used for all the dataframe types.
`flytekit.utils.rate_limiter.RateLimiter`	Rate limiter that allows up to a certain number of requests per minute.

Protocols

Protocol	Description
`flytekit.configuration.plugin.FlytekitPluginProtocol`
`flytekit.core.artifact.ArtifactSerializationHandler`	This protocol defines the interface for serializing artifact-related entities down to Flyte IDL.
`flytekit.core.cache.CachePolicy`
`flytekit.core.context_manager.SerializableToString`	This protocol is used by the Artifact create_from function.
`flytekit.core.promise.HasFlyteInterface`
`flytekit.core.promise.LocallyExecutable`
`flytekit.core.promise.SupportsNodeCreation`
`flytekit.core.schedule.LaunchPlanTriggerBase`
`flytekit.deck.renderer.Renderable`
`flytekit.sensor.base_sensor.SensorConfig`

Functions

Function	Description
`flytekit.current_context()`	Use this method to get a handle of specific parameters available in a flyte task.
`flytekit.load_implicit_plugins()`	This method allows loading all plugins that have the entrypoint specification.
`flytekit.new_context()`
`flytekit.bin.entrypoint.get_container_error_timestamp()`	Get timestamp for ContainerError.
`flytekit.bin.entrypoint.get_one_of()`	Helper function to iterate through a series of different environment variables.
`flytekit.bin.entrypoint.get_traceback_str()`
`flytekit.bin.entrypoint.get_version_message()`
`flytekit.bin.entrypoint.normalize_inputs()`
`flytekit.bin.entrypoint.setup_execution()`
`flytekit.clients.auth.default_html.get_default_success_html()`
`flytekit.clients.auth.token_client.get_basic_authorization_header()`	This function transforms the client id and the client secret into a header that conforms with http basic auth.
`flytekit.clients.auth.token_client.get_device_code()`	Retrieves the device Authentication code that can be done to authenticate the request using a browser on a separate device.
`flytekit.clients.auth.token_client.get_token()`	retrieved from the IDP, the third is the expiration in seconds.
`flytekit.clients.auth.token_client.poll_token_endpoint()`
`flytekit.clients.auth_helper.bootstrap_creds_from_server()`	Retrieves the SSL cert from the remote and uses that. should be used only if insecure-skip-verify.
`flytekit.clients.auth_helper.get_authenticated_channel()`	Returns a new channel for the given config that is authenticated.
`flytekit.clients.auth_helper.get_authenticator()`	Returns a new authenticator based on the platform config.
`flytekit.clients.auth_helper.get_channel()`	Creates a new grpc.Channel given a platformConfig.
`flytekit.clients.auth_helper.get_proxy_authenticator()`
`flytekit.clients.auth_helper.get_session()`	Return a new session for the given platform config.
`flytekit.clients.auth_helper.register_authenticator_plugin()`	Register an authenticator factory by name.
`flytekit.clients.auth_helper.upgrade_channel_to_authenticated()`	Given a grpc.Channel, preferably a secure channel, it returns a composed channel that uses Interceptor to perform an Oauth2.0 Auth flow.
`flytekit.clients.auth_helper.upgrade_channel_to_proxy_authenticated()`	If activated in the platform config, given a grpc.Channel, preferably a secure channel, it returns a composed channel that uses Interceptor to perform authentication with a proxy in front of Flyte.
`flytekit.clients.auth_helper.upgrade_session_to_proxy_authenticated()`	Given a requests.Session, it returns a new session that uses a custom HTTPAdapter to perform authentication with a proxy in front of Flyte.
`flytekit.clients.auth_helper.wrap_exceptions_channel()`	Wraps the input channel with RetryExceptionWrapperInterceptor.
`flytekit.clients.grpc_utils.deadline_interceptor.get_scoped_grpc_deadline()`
`flytekit.clients.grpc_utils.deadline_interceptor.scoped_grpc_deadline()`
`flytekit.clients.helpers.iterate_node_executions()`	This returns a generator for node executions.
`flytekit.clients.helpers.iterate_task_executions()`	This returns a generator for task executions, given a node execution identifier.
`flytekit.clis.helpers.display_help_with_error()`
`flytekit.clis.helpers.hydrate_registration_parameters()`	This is called at registration time to fill out identifier fields (e.g. project, domain, version) that are mutable.
`flytekit.clis.helpers.parse_args_into_dict()`	Takes a tuple like (u’input_b=mystr’, u’input_c=18’) and returns a dictionary of input name to the original string value.
`flytekit.clis.helpers.str2bool()`	bool(‘False’) is True in Python, so we need to do some string parsing.
`flytekit.clis.sdk_in_container.backfill.resolve_backfill_window()`	Resolves the from_date -> to_date.
`flytekit.clis.sdk_in_container.build.build_command()`	Returns a function that is used to implement WorkflowCommand and build an image for flyte workflows.
`flytekit.clis.sdk_in_container.helpers.get_and_save_remote_with_click_context()`	NB: This function will by default mutate the click Context.obj dictionary, adding a remote key with value of the created FlyteRemote object.
`flytekit.clis.sdk_in_container.helpers.parse_copy()`	Helper function to parse cmd line args into enum.
`flytekit.clis.sdk_in_container.helpers.patch_image_config()`	Merge ImageConfig object with images defined in config file.
`flytekit.clis.sdk_in_container.run.dump_flyte_remote_snippet()`
`flytekit.clis.sdk_in_container.run.get_entities_in_file()`	Returns a list of flyte workflow names and list of Flyte tasks in a file.
`flytekit.clis.sdk_in_container.run.is_optional()`	Checks if the given type is Optional Type.
`flytekit.clis.sdk_in_container.run.load_naive_entity()`	Load the workflow of a script file.
`flytekit.clis.sdk_in_container.run.options_from_run_params()`
`flytekit.clis.sdk_in_container.run.run_command()`	Returns a function that is used to implement WorkflowCommand and execute a flyte workflow.
`flytekit.clis.sdk_in_container.run.run_remote()`	Helper method that executes the given remote FlyteLaunchplan, FlyteWorkflow or FlyteTask.
`flytekit.clis.sdk_in_container.run.to_click_option()`	This handles converting workflow input types to supported click parameters with callbacks to initialize the input values to their expected types.
`flytekit.clis.sdk_in_container.serialize.serialize_all()`	flyteidl.admin.launch_plan_pb2.LaunchPlan flyteidl.admin.workflow_pb2.WorkflowSpec flyteidl.admin.task_pb2.TaskSpec ```.
`flytekit.clis.sdk_in_container.serve.print_metadata()`
`flytekit.clis.sdk_in_container.utils.get_option_from_metadata()`
`flytekit.clis.sdk_in_container.utils.make_click_option_field()`
`flytekit.clis.sdk_in_container.utils.pretty_print_exception()`	This method will print the exception in a nice way.
`flytekit.clis.sdk_in_container.utils.pretty_print_grpc_error()`	This method will print the grpc error that us more human readable.
`flytekit.clis.sdk_in_container.utils.pretty_print_traceback()`	This method will print the Traceback of an error.
`flytekit.clis.sdk_in_container.utils.remove_unwanted_traceback_frames()`	Custom function to remove certain frames from the traceback.
`flytekit.clis.sdk_in_container.utils.validate_package()`	This method will validate the packages passed in by the user.
`flytekit.configuration.file.bool_transformer()`
`flytekit.configuration.file.comma_list_transformer()`
`flytekit.configuration.file.int_transformer()`
`flytekit.configuration.file.read_file_if_exists()`	Reads the contents of the file if passed a path.
`flytekit.configuration.file.set_if_exists()`	Given a dict `d` sets the key `k` with value of config `v`, if the config value `v` is set and return the updated dictionary.
`flytekit.configuration.plugin.get_plugin()`	Get current plugin.
`flytekit.core.array_node.array_node()`	ArrayNode implementation that maps over tasks and other Flyte entities.
`flytekit.core.array_node_map_task.array_node_map_task()`	Map task that uses the `ArrayNode` construct..
`flytekit.core.array_node_map_task.map_task()`	Wrapper that creates a map task utilizing either the existing ArrayNodeMapTask or the drop in replacement ArrayNode implementation.
`flytekit.core.artifact_utils.idl_partitions_from_dict()`
`flytekit.core.artifact_utils.idl_time_partition_from_datetime()`
`flytekit.core.base_task.kwtypes()`	This is a small helper function to convert the keyword arguments to an OrderedDict of types.
`flytekit.core.condition.conditional()`	Use a conditional section to control the flow of a workflow.
`flytekit.core.condition.create_branch_node_promise_var()`	Generates a globally (wf-level) unique id for a variable.
`flytekit.core.condition.merge_promises()`
`flytekit.core.condition.to_branch_node()`
`flytekit.core.condition.to_case_block()`
`flytekit.core.condition.to_ifelse_block()`
`flytekit.core.condition.transform_to_boolexpr()`
`flytekit.core.condition.transform_to_comp_expr()`
`flytekit.core.condition.transform_to_conj_expr()`
`flytekit.core.condition.transform_to_operand()`
`flytekit.core.data_persistence.azure_setup_args()`
`flytekit.core.data_persistence.get_additional_fsspec_call_kwargs()`	These are different from the setup args functions defined above.
`flytekit.core.data_persistence.get_fsspec_storage_options()`
`flytekit.core.data_persistence.s3_setup_args()`
`flytekit.core.environment.forge()`
`flytekit.core.environment.inherit()`
`flytekit.core.gate.approve()`	Create a Gate object for binary approval.
`flytekit.core.gate.sleep()`	Create a sleep Gate object.
`flytekit.core.gate.wait_for_input()`	Create a Gate object that waits for user input of the specified type.
`flytekit.core.interface.default_output_name()`
`flytekit.core.interface.detect_artifact()`	If the user wishes to control how Artifacts are created (i.e. naming them, etc.) this is where we pick it up and store it in the interface.
`flytekit.core.interface.extract_return_annotation()`	The purpose of this function is to sort out whether a function is returning one thing, or multiple things, and to name the outputs accordingly, either by using our default name function, or from a typing.NamedTuple.
`flytekit.core.interface.output_name_generator()`
`flytekit.core.interface.remap_shared_output_descriptions()`	Deals with mixed styles of return value descriptions used in docstrings.
`flytekit.core.interface.repr_kv()`
`flytekit.core.interface.repr_type_signature()`	Converts an inputs and outputs to a type signature.
`flytekit.core.interface.transform_function_to_interface()`	From the annotations on a task function that the user should have provided, and the output names they want to use for each output parameter, construct the TypedInterface object.
`flytekit.core.interface.transform_inputs_to_parameters()`	Transforms the given interface (with inputs) to a Parameter Map with defaults set.
`flytekit.core.interface.transform_interface_to_list_interface()`	Takes a single task interface and interpolates it to an array interface - to allow performing distributed python map like functions.
`flytekit.core.interface.transform_interface_to_typed_interface()`	Transform the given simple python native interface to FlyteIDL’s interface.
`flytekit.core.interface.transform_type()`
`flytekit.core.interface.transform_types_to_list_of_type()`	Converts unbound inputs into the equivalent (optional) collections.
`flytekit.core.interface.transform_variable_map()`	Given a map of str (names of inputs for instance) to their Python native types, return a map of the name to a Flyte Variable object with that type.
`flytekit.core.interface.verify_outputs_artifact_bindings()`
`flytekit.core.launch_plan.reference_launch_plan()`	A reference launch plan is a pointer to a launch plan that already exists on your Flyte installation.
`flytekit.core.legacy_map_task.map_task()`	Use a map task for parallelizable tasks that run across a list of an input type.
`flytekit.core.node.assert_no_promises_in_resources()`	This function will raise an exception if any of the resources have promises in them.
`flytekit.core.node.assert_not_promise()`	This function will raise an exception if the value is a promise.
`flytekit.core.node_creation.create_node()`	This is the function you want to call if you need to specify dependencies between tasks that don’t consume and/or don’t produce outputs.
`flytekit.core.pod_template.serialize_pod_template()`
`flytekit.core.promise.async_flyte_entity_call_handler()`	This is a limited async version of the main call handler.
`flytekit.core.promise.binding_data_from_python_std()`
`flytekit.core.promise.binding_from_python_std()`
`flytekit.core.promise.create_and_link_node()`
`flytekit.core.promise.create_and_link_node_from_remote()`	This method is used to generate a node with bindings especially when using remote entities, like FlyteWorkflow, FlyteTask and FlyteLaunchplan.
`flytekit.core.promise.create_native_named_tuple()`	Creates and returns a Named tuple with all variables that match the expected named outputs. this makes it possible to run things locally and expect a more native behavior, i.e. address elements of a named tuple by name.
`flytekit.core.promise.create_task_output()`
`flytekit.core.promise.extract_obj_name()`	Generates a shortened name, without the module information.
`flytekit.core.promise.flyte_entity_call_handler()`	This function is the call handler for tasks, workflows, and launch plans (which redirects to the underlying workflow).
`flytekit.core.promise.get_primitive_val()`
`flytekit.core.promise.resolve_attr_path_in_dict()`
`flytekit.core.promise.resolve_attr_path_in_pb_struct()`	Resolves the protobuf struct (e.g. dataclass) with attribute path.
`flytekit.core.promise.resolve_attr_path_in_promise()`	resolve_attr_path_in_promise resolves the attribute path in a promise and returns a new promise with the resolved value This is for local execution only.
`flytekit.core.promise.resolve_attr_path_recursively()`	This function resolves the attribute path in a nested structure recursively.
`flytekit.core.promise.to_binding()`
`flytekit.core.promise.translate_inputs_to_literals()`	The point of this function is to extract out Literals from a collection of either Python native values (which would be converted into Flyte literals) or Promises (the literals in which would just get extracted).
`flytekit.core.promise.translate_inputs_to_native()`
`flytekit.core.python_auto_container.get_registerable_container_image()`	Resolve the image to the real image name that should be used for registration.
`flytekit.core.python_auto_container.update_image_spec_copy_handling()`	This helper function is where the relationship between fast register and ImageSpec is codified.
`flytekit.core.reference.get_reference_entity()`	See the documentation for `flytekit.reference_task` and `flytekit.reference_workflow` as well.
`flytekit.core.resources.construct_extended_resources()`	Convert public extended resources to idl.
`flytekit.core.resources.convert_resources_to_resource_model()`	Convert flytekit `Resources` objects to a Resources model.
`flytekit.core.resources.pod_spec_from_resources()`
`flytekit.core.task.decorate_function()`	Decorates the task with additional functionality if necessary.
`flytekit.core.task.eager()`	Eager workflow decorator.
`flytekit.core.task.reference_task()`	A reference task is a pointer to a task that already exists on your Flyte installation.
`flytekit.core.task.task()`	This is the core decorator to use for any task type in flytekit.
`flytekit.core.testing.patch()`	This is a decorator used for testing.
`flytekit.core.testing.task_mock()`	Use this method to mock a task declaration.
`flytekit.core.tracker.extract_task_module()`	Returns the task-name, absolute module and the string name of the callable.
`flytekit.core.tracker.get_full_module_path()`
`flytekit.core.tracker.import_module_from_file()`
`flytekit.core.tracker.is_functools_wrapped_module_level()`	Returns true if the function is a functools.wraps-updated function that is defined in the module-level scope.
`flytekit.core.tracker.is_ipython_or_pickle_exists()`	Returns true if the code is running in an IPython notebook or if a pickle file exists.
`flytekit.core.tracker.isnested()`	Returns true if a function is local to another function and is not accessible through a module.
`flytekit.core.tracker.istestfunction()`	Return true if the function is defined in a test module.
`flytekit.core.type_engine.convert_marshmallow_json_schema_to_python_class()`	Generate a model class based on the provided JSON Schema.
`flytekit.core.type_engine.convert_mashumaro_json_schema_to_python_class()`	Generate a model class based on the provided JSON Schema.
`flytekit.core.type_engine.dataclass_from_dict()`	Utility function to construct a dataclass object from dict.
`flytekit.core.type_engine.generate_attribute_list_from_dataclass_json()`
`flytekit.core.type_engine.generate_attribute_list_from_dataclass_json_mixin()`
`flytekit.core.type_engine.get_batch_size()`
`flytekit.core.type_engine.get_underlying_type()`	Return the underlying type for annotated types or the type itself.
`flytekit.core.type_engine.is_annotated()`
`flytekit.core.type_engine.modify_literal_uris()`	Modifies the literal object recursively to replace the URIs with the native paths in case they are of type “flyte://”.
`flytekit.core.type_engine.strict_type_hint_matching()`	Try to be smarter about guessing the type of the input (and hence the transformer).
`flytekit.core.type_helpers.load_type_from_tag()`	Loads python type from tag.
`flytekit.core.type_match_checking.literal_types_match()`	Returns if two LiteralTypes are the same.
`flytekit.core.utils.has_return_statement()`
`flytekit.core.utils.load_proto_from_file()`
`flytekit.core.utils.str2bool()`	Convert a string to a boolean.
`flytekit.core.utils.write_proto_to_file()`
`flytekit.core.workflow.construct_input_promises()`
`flytekit.core.workflow.get_promise()`	This is a helper function that will turn a binding into a Promise object, using a lookup map.
`flytekit.core.workflow.get_promise_map()`	Local execution of imperatively defined workflows is done node by node.
`flytekit.core.workflow.reference_workflow()`	A reference workflow is a pointer to a workflow that already exists on your Flyte installation.
`flytekit.core.workflow.workflow()`	This decorator declares a function to be a Flyte workflow.
`flytekit.deck.deck.generate_time_table()`
`flytekit.deck.deck.get_deck_template()`
`flytekit.exceptions.scopes.system_entry_point()`	The reason these two (see the user one below) decorators exist is to categorize non-Flyte exceptions at arbitrary locations.
`flytekit.exceptions.scopes.user_entry_point()`	See the comment for the system_entry_point above as well.
`flytekit.exceptions.utils.annotate_exception_with_code()`	Annotate the exception with the source code, and will be printed in the rich panel.
`flytekit.exceptions.utils.get_source_code_from_fn()`	Get the source code of the function and the column offset of the parameter defined in the input signature.
`flytekit.extend.backend.connector_service.record_connector_metrics()`
`flytekit.extend.backend.utils.convert_to_flyte_phase()`	Convert the state from the connector to the phase in flyte.
`flytekit.extend.backend.utils.get_agent_secret()`
`flytekit.extend.backend.utils.get_connector_secret()`
`flytekit.extend.backend.utils.is_terminal_phase()`	Return true if the phase is terminal.
`flytekit.extend.backend.utils.mirror_async_methods()`
`flytekit.extend.backend.utils.render_task_template()`
`flytekit.extras.sqlite3.task.unarchive_file()`	Unarchive given archive and returns the unarchived file name.
`flytekit.extras.tasks.shell.get_raw_shell_task()`
`flytekit.extras.tasks.shell.subproc_execute()`	Execute a command and capture its stdout and stderr.
`flytekit.image_spec.default_builder.create_docker_context()`	Populate tmp_dir with Dockerfile as specified by the `image_spec`.
`flytekit.image_spec.default_builder.get_flytekit_for_pypi()`	Get flytekit version on PyPI.
`flytekit.image_spec.default_builder.prepare_poetry_lock_command()`
`flytekit.image_spec.default_builder.prepare_python_executable()`
`flytekit.image_spec.default_builder.prepare_python_install()`
`flytekit.image_spec.default_builder.prepare_uv_lock_command()`
`flytekit.image_spec.image_spec.validate_container_registry_name()`	Validate Docker container registry name.
`flytekit.interaction.click_types.is_pydantic_basemodel()`	Checks if the python type is a pydantic BaseModel.
`flytekit.interaction.click_types.key_value_callback()`	Callback for click to parse key-value pairs.
`flytekit.interaction.click_types.labels_callback()`	Callback for click to parse labels.
`flytekit.interaction.click_types.literal_type_to_click_type()`	Converts a Flyte LiteralType given a python_type to a click.ParamType.
`flytekit.interaction.click_types.modify_literal_uris()`	Modifies the literal object recursively to replace the URIs with the native paths.
`flytekit.interaction.click_types.resource_callback()`	Click callback to parse resource strings like ‘cpu=1,mem=2Gi’ into a Resources object.
`flytekit.interaction.parse_stdin.parse_stdin_to_literal()`	Parses the user input from stdin and converts it to a literal of the given type.
`flytekit.interaction.string_literals.literal_map_string_repr()`	This method is used to convert a literal map to a string representation.
`flytekit.interaction.string_literals.literal_string_repr()`	This method is used to convert a literal to a string representation.
`flytekit.interaction.string_literals.primitive_to_string()`	This method is used to convert a primitive to a string representation.
`flytekit.interaction.string_literals.scalar_to_string()`	This method is used to convert a scalar to a string representation.
`flytekit.interactive.utils.execute_command()`	Execute a command in the shell.
`flytekit.interactive.utils.get_task_inputs()`	Read task input data from inputs.pb for a specific task function and convert it into Python types and structures.
`flytekit.interactive.utils.load_module_from_path()`	Imports a Python module from a specified file path.
`flytekit.interactive.vscode_lib.decorator.download_file()`	Download a file from a given URL using fsspec.
`flytekit.interactive.vscode_lib.decorator.download_vscode()`	Download vscode server and extension from remote to local and add the directory of binary executable to $PATH.
`flytekit.interactive.vscode_lib.decorator.exit_handler()`	1.
`flytekit.interactive.vscode_lib.decorator.get_code_server_info()`	Returns the code server information based on the system’s architecture.
`flytekit.interactive.vscode_lib.decorator.get_installed_extensions()`	Get the list of installed extensions.
`flytekit.interactive.vscode_lib.decorator.is_extension_installed()`
`flytekit.interactive.vscode_lib.decorator.prepare_interactive_python()`	1.
`flytekit.interactive.vscode_lib.decorator.prepare_launch_json()`	Generate the launch.json and settings.json for users to easily launch interactive debugging and task resumption.
`flytekit.interactive.vscode_lib.decorator.prepare_resume_task_python()`	Generate a Python script for users to resume the task.
`flytekit.interfaces.random.seed_flyte_random()`	If one wants to influence the pseudo-random behavior of flytekit, this function can be used to seed the flytekit generator.
`flytekit.interfaces.stats.client.get_base_stats()`
`flytekit.interfaces.stats.client.get_stats()`
`flytekit.interfaces.stats.taggable.get_stats()`
`flytekit.lazy_import.lazy_module.is_imported()`	This function is used to check if a module has been imported by the regular import.
`flytekit.lazy_import.lazy_module.lazy_module()`	This function is used to lazily import modules.
`flytekit.loggers.get_level_from_cli_verbosity()`	Converts a verbosity level from the CLI to a logging level.
`flytekit.loggers.initialize_global_loggers()`	Initializes the global loggers to the default configuration.
`flytekit.loggers.is_display_progress_enabled()`
`flytekit.loggers.is_rich_logging_enabled()`
`flytekit.loggers.set_developer_properties()`	developer logger is only used for debugging.
`flytekit.loggers.set_flytekit_log_properties()`	flytekit logger, refers to the framework logger.
`flytekit.loggers.set_user_logger_properties()`	user_space logger, refers to the user’s logger.
`flytekit.loggers.upgrade_to_rich_logging()`
`flytekit.remote.backfill.create_backfill_workflow()`	Generates a new imperative workflow for the launchplan that can be used to backfill the given launchplan.
`flytekit.remote.data.download_literal()`	Download a single literal to a file, if it is a blob or structured dataset.
`flytekit.remote.metrics.aggregate_reference_span()`
`flytekit.remote.metrics.aggregate_spans()`
`flytekit.remote.metrics.print_span()`
`flytekit.remote.remote_fs.get_flyte_fs()`
`flytekit.tools.fast_registration.compress_tarball()`	Compress code tarball using pigz if available, otherwise gzip.
`flytekit.tools.fast_registration.compute_digest()`	Walks the entirety of the source dir to compute a deterministic md5 hex digest of the dir contents. :return Text.
`flytekit.tools.fast_registration.download_distribution()`	Downloads a remote code distribution and overwrites any local files.
`flytekit.tools.fast_registration.fast_package()`	Takes a source directory and packages everything not covered by common ignores into a tarball named after a hexdigest of the included files. :return os.PathLike.
`flytekit.tools.fast_registration.get_additional_distribution_loc()`	:return Text.
`flytekit.tools.fast_registration.print_ls_tree()`
`flytekit.tools.interactive.ipython_check()`	Check if interface is launching from iPython (not colab) :return is_ipython (bool): True or False.
`flytekit.tools.module_loader.add_sys_path()`	Temporarily add given path to `sys.path`.
`flytekit.tools.module_loader.just_load_modules()`	This one differs from the above in that we don’t yield anything, just load all the modules.
`flytekit.tools.module_loader.load_object_from_module()`	TODO: Handle corner cases, like where the first part is [] maybe.
`flytekit.tools.module_loader.module_load_error_handler()`
`flytekit.tools.repo.find_common_root()`	Given an arbitrary list of folders and files, this function will use the script mode function to walk up the filesystem to find the first folder without an init file.
`flytekit.tools.repo.list_packages_and_modules()`	This is a helper function that returns the input list of python packages/modules as a dot delinated list relative to the given project_root.
`flytekit.tools.repo.package()`	Package the given entities and the source code (if fast is enabled) into a package with the given name in output.
`flytekit.tools.repo.print_registration_status()`
`flytekit.tools.repo.register()`	Temporarily, for fast register, specify both the fast arg as well as copy_style. fast == True with copy_style == None means use the old fast register tar’ring method.
`flytekit.tools.repo.serialize_and_package()`	Fist serialize and then package all entities Temporarily for fast package, specify both the fast arg as well as copy_style. fast == True with copy_style == None means use the old fast register tar’ring method.
`flytekit.tools.repo.serialize_get_control_plane_entities()`	See `flytekit.models.core.identifier.ResourceType` to match the trailing index in the file name with the entity type.
`flytekit.tools.repo.serialize_load_only()`	See `flytekit.models.core.identifier.ResourceType` to match the trailing index in the file name with the entity type.
`flytekit.tools.repo.serialize_to_folder()`	Serialize the given set of python packages to a folder.
`flytekit.tools.script_mode.add_imported_modules_from_source()`	Copies modules into destination that are in modules.
`flytekit.tools.script_mode.compress_scripts()`	Compresses the single script while maintaining the folder structure for that file.
`flytekit.tools.script_mode.get_all_modules()`	Import python file with module_name in source_path and return all modules.
`flytekit.tools.script_mode.list_all_files()`
`flytekit.tools.script_mode.list_imported_modules_as_files()`	Copies modules into destination that are in modules.
`flytekit.tools.script_mode.ls_files()`	user_modules_and_packages is a list of the Python modules and packages, expressed as absolute paths, that the user has run this pyflyte command with.
`flytekit.tools.script_mode.tar_strip_file_attributes()`
`flytekit.tools.serialize_helpers.get_registrable_entities()`	Returns all entities that can be serialized and should be sent over to Flyte backend.
`flytekit.tools.serialize_helpers.persist_registrable_entities()`	For protobuf serializable list of entities, writes a file with the name if the entity and enumeration order to the specified folder.
`flytekit.tools.subprocess.check_call()`
`flytekit.tools.translator.gather_dependent_entities()`	The `get_serializable` function above takes in an `OrderedDict` that helps keep track of dependent entities.
`flytekit.tools.translator.get_command_prefix_for_fast_execute()`
`flytekit.tools.translator.get_reference_spec()`
`flytekit.tools.translator.get_serializable()`	The flytekit authoring code produces objects representing Flyte entities (tasks, workflows, etc.).
`flytekit.tools.translator.get_serializable_array_node()`
`flytekit.tools.translator.get_serializable_array_node_map_task()`
`flytekit.tools.translator.get_serializable_branch_node()`
`flytekit.tools.translator.get_serializable_flyte_task()`	TODO replace with deep copy.
`flytekit.tools.translator.get_serializable_flyte_workflow()`	TODO replace with deep copy.
`flytekit.tools.translator.get_serializable_launch_plan()`
`flytekit.tools.translator.get_serializable_node()`
`flytekit.tools.translator.get_serializable_task()`
`flytekit.tools.translator.get_serializable_workflow()`
`flytekit.tools.translator.prefix_with_fast_execute()`
`flytekit.tools.translator.to_serializable_case()`
`flytekit.tools.translator.to_serializable_cases()`
`flytekit.types.directory.types.noop()`
`flytekit.types.file.file.noop()`
`flytekit.types.numpy.ndarray.extract_metadata()`
`flytekit.types.schema.types.generate_ordered_files()`
`flytekit.types.structured.lazy_import_structured_dataset_handler()`
`flytekit.types.structured.basic_dfs.get_pandas_storage_options()`
`flytekit.types.structured.snowflake.get_private_key()`
`flytekit.types.structured.structured_dataset.convert_schema_type_to_structured_dataset_type()`
`flytekit.types.structured.structured_dataset.extract_cols_and_format()`	Helper function, just used to iterate through Annotations and extract out the following information.
`flytekit.types.structured.structured_dataset.flatten_dict()`
`flytekit.types.structured.structured_dataset.get_supported_types()`
`flytekit.utils.dict_formatter.format_dict()`	Recursively update a dictionary with format strings with values from another dictionary where the keys match the format string.
`flytekit.utils.dict_formatter.get_nested_value()`	Retrieve the nested value from a dictionary based on a list of keys.
`flytekit.utils.dict_formatter.replace_placeholder()`	Replace a placeholder in the original string and handle the specific logic for the sagemaker service and idempotence token.
`flytekit.utils.pbhash.compute_hash()`	Computes a deterministic hash in bytes for the Protobuf object.
`flytekit.utils.pbhash.compute_hash_string()`	Computes a deterministic hash in base64 encoded string for the Protobuf object.

Packages

Package	Description
`flytekit`	This package contains all of the most common abstractions you’ll need to write Flyte workflows and extend Flytekit.
`flytekit.bin.entrypoint`
`flytekit.clients.auth.auth_client`
`flytekit.clients.auth.authenticator`
`flytekit.clients.auth.default_html`
`flytekit.clients.auth.exceptions`
`flytekit.clients.auth.keyring`
`flytekit.clients.auth.token_client`
`flytekit.clients.auth_helper`
`flytekit.clients.friendly`
`flytekit.clients.grpc_utils.auth_interceptor`
`flytekit.clients.grpc_utils.deadline_interceptor`
`flytekit.clients.grpc_utils.default_metadata_interceptor`
`flytekit.clients.grpc_utils.wrap_exception_interceptor`
`flytekit.clients.helpers`
`flytekit.clients.raw`
`flytekit.clis.helpers`
`flytekit.clis.sdk_in_container.backfill`
`flytekit.clis.sdk_in_container.build`
`flytekit.clis.sdk_in_container.constants`
`flytekit.clis.sdk_in_container.executions`
`flytekit.clis.sdk_in_container.helpers`
`flytekit.clis.sdk_in_container.metrics`
`flytekit.clis.sdk_in_container.package`
`flytekit.clis.sdk_in_container.pyflyte`
`flytekit.clis.sdk_in_container.run`
`flytekit.clis.sdk_in_container.serialize`
`flytekit.clis.sdk_in_container.serve`
`flytekit.clis.sdk_in_container.utils`
`flytekit.clis.version`
`flytekit.configuration`	There are multiple ways to configure flytekit settings.
`flytekit.configuration.default_images`
`flytekit.configuration.feature_flags`
`flytekit.configuration.file`
`flytekit.configuration.internal`
`flytekit.configuration.plugin`	Defines a plugin API allowing other libraries to modify the behavior of flytekit.
`flytekit.constants`
`flytekit.core.annotation`
`flytekit.core.array_node`
`flytekit.core.array_node_map_task`
`flytekit.core.artifact`
`flytekit.core.artifact_utils`
`flytekit.core.base_sql_task`
`flytekit.core.base_task`	This module provides the core task-related functionality in Flytekit.
`flytekit.core.cache`
`flytekit.core.checkpointer`
`flytekit.core.class_based_resolver`
`flytekit.core.condition`
`flytekit.core.constants`
`flytekit.core.container_task`
`flytekit.core.context_manager`	These classes provide functionality related context management.
`flytekit.core.data_persistence`	The Data persistence module is used by core flytekit and most of the core TypeTransformers to manage data fetch & store, between the durable backend store and the runtime environment.
`flytekit.core.docstring`
`flytekit.core.environment`
`flytekit.core.gate`
`flytekit.core.hash`
`flytekit.core.interface`
`flytekit.core.launch_plan`
`flytekit.core.legacy_map_task`	Flytekit map tasks specify how to run a single task across a list of inputs.
`flytekit.core.local_cache`
`flytekit.core.local_fsspec`
`flytekit.core.mock_stats`
`flytekit.core.node`
`flytekit.core.node_creation`
`flytekit.core.notification`	Notifications are primarily used when defining Launch Plans (also can be used when launching executions) and will trigger the Flyte platform to send emails when a workflow run reaches certain stages (fails or succeeds, etc.).
`flytekit.core.options`
`flytekit.core.pod_template`
`flytekit.core.promise`
`flytekit.core.python_auto_container`
`flytekit.core.python_customized_container_task`
`flytekit.core.python_function_task`
`flytekit.core.reference`
`flytekit.core.reference_entity`
`flytekit.core.resources`
`flytekit.core.schedule`	These classes provide functionality related to schedules.
`flytekit.core.shim_task`
`flytekit.core.task`
`flytekit.core.testing`
`flytekit.core.tracked_abc`
`flytekit.core.tracker`
`flytekit.core.type_engine`
`flytekit.core.type_helpers`
`flytekit.core.type_match_checking`
`flytekit.core.utils`
`flytekit.core.worker_queue`
`flytekit.core.workflow`
`flytekit.deck.deck`
`flytekit.deck.renderer`
`flytekit.exceptions.base`
`flytekit.exceptions.eager`
`flytekit.exceptions.scopes`
`flytekit.exceptions.system`
`flytekit.exceptions.user`
`flytekit.exceptions.utils`
`flytekit.experimental.eager_function`
`flytekit.extend.backend.base_connector`
`flytekit.extend.backend.connector_service`
`flytekit.extend.backend.utils`
`flytekit.extras.accelerators`	tags: MachineLearning, Advanced, Hardware.
`flytekit.extras.cloud_pickle_resolver`
`flytekit.extras.pydantic_transformer.transformer`
`flytekit.extras.sklearn.native`
`flytekit.extras.sqlite3.task`
`flytekit.extras.tasks.shell`
`flytekit.extras.webhook`
`flytekit.extras.webhook.connector`
`flytekit.extras.webhook.constants`
`flytekit.extras.webhook.task`
`flytekit.image_spec.default_builder`
`flytekit.image_spec.image_spec`
`flytekit.image_spec.noop_builder`
`flytekit.interaction.click_types`
`flytekit.interaction.parse_stdin`
`flytekit.interaction.rich_utils`
`flytekit.interaction.string_literals`
`flytekit.interactive`	This module provides functionality related to Flytekit Interactive.
`flytekit.interactive.constants`
`flytekit.interactive.utils`
`flytekit.interactive.vscode_lib.config`
`flytekit.interactive.vscode_lib.decorator`
`flytekit.interactive.vscode_lib.vscode_constants`
`flytekit.interfaces.cli_identifiers`
`flytekit.interfaces.random`
`flytekit.interfaces.stats.client`
`flytekit.interfaces.stats.taggable`
`flytekit.lazy_import.lazy_module`
`flytekit.loggers`
`flytekit.models.admin.common`
`flytekit.models.admin.task_execution`
`flytekit.models.admin.workflow`
`flytekit.models.annotation`
`flytekit.models.array_job`
`flytekit.models.common`
`flytekit.models.concurrency`
`flytekit.models.core.catalog`
`flytekit.models.core.compiler`
`flytekit.models.core.condition`
`flytekit.models.core.errors`
`flytekit.models.core.execution`
`flytekit.models.core.identifier`
`flytekit.models.core.types`
`flytekit.models.core.workflow`
`flytekit.models.documentation`
`flytekit.models.domain`
`flytekit.models.dynamic_job`
`flytekit.models.event`
`flytekit.models.execution`
`flytekit.models.filters`
`flytekit.models.interface`
`flytekit.models.launch_plan`
`flytekit.models.literals`
`flytekit.models.matchable_resource`
`flytekit.models.named_entity`
`flytekit.models.node_execution`
`flytekit.models.presto`	This is a deprecated module.
`flytekit.models.project`
`flytekit.models.qubole`	This is a deprecated module.
`flytekit.models.schedule`
`flytekit.models.security`
`flytekit.models.task`
`flytekit.models.types`
`flytekit.models.workflow_closure`
`flytekit.remote.backfill`
`flytekit.remote.data`
`flytekit.remote.entities`	This module contains shadow entities for all Flyte entities as represented in Flyte Admin / Control Plane.
`flytekit.remote.executions`
`flytekit.remote.interface`
`flytekit.remote.lazy_entity`
`flytekit.remote.metrics`
`flytekit.remote.remote`	This module provides the `FlyteRemote` object, which is the end-user’s main starting point for interacting with a Flyte backend in an interactive and programmatic way.
`flytekit.remote.remote_callable`
`flytekit.remote.remote_fs`
`flytekit.sensor.base_sensor`
`flytekit.sensor.file_sensor`
`flytekit.sensor.sensor_engine`
`flytekit.tools.fast_registration`
`flytekit.tools.ignore`
`flytekit.tools.interactive`
`flytekit.tools.module_loader`
`flytekit.tools.repo`
`flytekit.tools.script_mode`
`flytekit.tools.serialize_helpers`
`flytekit.tools.subprocess`
`flytekit.tools.translator`
`flytekit.types.directory`	Similar to `flytekit.types.file.FlyteFile` there are some ‘preformatted’ directory types.
`flytekit.types.directory.types`
`flytekit.types.error.error`
`flytekit.types.file`	This module provides functionality related to FlyteFile.
`flytekit.types.file.file`
`flytekit.types.file.image`
`flytekit.types.iterator.iterator`
`flytekit.types.iterator.json_iterator`
`flytekit.types.numpy.ndarray`
`flytekit.types.pickle.pickle`
`flytekit.types.schema.types`
`flytekit.types.schema.types_pandas`
`flytekit.types.structured`
`flytekit.types.structured.basic_dfs`
`flytekit.types.structured.bigquery`
`flytekit.types.structured.snowflake`
`flytekit.types.structured.structured_dataset`
`flytekit.utils.asyn`	Manages an async event loop on another thread.
`flytekit.utils.dict_formatter`
`flytekit.utils.pbhash`
`flytekit.utils.rate_limiter`