abacusai.project
================

.. py:module:: abacusai.project


Classes
-------

.. autoapisummary::

   abacusai.project.Project


Module Contents
---------------

.. py:class:: Project(client, projectId=None, name=None, useCase=None, problemType=None, createdAt=None, tags=None)

   Bases: :py:obj:`abacusai.return_class.AbstractApiClass`


   A project is a container which holds datasets, models and deployments

   :param client: An authenticated API Client instance
   :type client: ApiClient
   :param projectId: The ID of the project.
   :type projectId: str
   :param name: The name of the project.
   :type name: str
   :param useCase: The use case associated with the project.
   :type useCase: str
   :param problemType: The problem type associated with the project.
   :type problemType: str
   :param createdAt: The date and time when the project was created.
   :type createdAt: str
   :param tags: List of tags associated with the project.
   :type tags: list[str]


   .. py:method:: __repr__()

      Return repr(self).



   .. py:method:: to_dict()

      Get a dict representation of the parameters in this class

      :returns: The dict value representation of the class parameters
      :rtype: dict



   .. py:method:: refresh()

      Calls describe and refreshes the current object's fields

      :returns: The current object
      :rtype: Project



   .. py:method:: describe()

      Returns a description of a project.

      :param project_id: A unique string identifier for the project.
      :type project_id: str

      :returns: The description of the project.
      :rtype: Project



   .. py:method:: rename(name)

      This method renames a project after it is created.

      :param name: The new name for the project.
      :type name: str



   .. py:method:: delete()

      Delete a specified project from your organization.

      This method deletes the project, its associated trained models, and deployments. The datasets attached to the specified project remain available for use with other projects in the organization.

      This method will not delete a project that contains active deployments. Ensure that all active deployments are stopped before using the delete option.

      Note: All projects, models, and deployments cannot be recovered once they are deleted.


      :param project_id: The unique ID of the project to delete.
      :type project_id: str



   .. py:method:: add_tags(tags)

      This method adds a tag to a project.

      :param tags: The tags to add to the project.
      :type tags: list



   .. py:method:: remove_tags(tags)

      This method removes a tag from a project.

      :param tags: The tags to remove from the project.
      :type tags: list



   .. py:method:: set_feature_mapping(feature_group_id, feature_name, feature_mapping = None, nested_column_name = None)

      Set a column's feature mapping. If the column mapping is single-use and already set in another column in this feature group, this call will first remove the other column's mapping and move it to this column.

      :param feature_group_id: The unique ID associated with the feature group.
      :type feature_group_id: str
      :param feature_name: The name of the feature.
      :type feature_name: str
      :param feature_mapping: The mapping of the feature in the feature group.
      :type feature_mapping: str
      :param nested_column_name: The name of the nested column if the input feature is part of a nested feature group for the given feature_group_id.
      :type nested_column_name: str

      :returns: A list of objects that describes the resulting feature group's schema after the feature's featureMapping is set.
      :rtype: list[Feature]



   .. py:method:: validate(feature_group_ids = None)

      Validates that the specified project has all required feature group types for its use case and that all required feature columns are set.

      :param feature_group_ids: The list of feature group IDs to validate.
      :type feature_group_ids: List

      :returns: The project validation. If the specified project is missing required columns or feature groups, the response includes an array of objects for each missing required feature group and the missing required features in each feature group.
      :rtype: ProjectValidation



   .. py:method:: infer_feature_mappings(feature_group_id)

      Infer the feature mappings for the feature group in the project based on the problem type.

      :param feature_group_id: The unique ID associated with the feature group.
      :type feature_group_id: str

      :returns: A dict that contains the inferred feature mappings.
      :rtype: InferredFeatureMappings



   .. py:method:: describe_feature_group(feature_group_id)

      Describe a feature group associated with a project

      :param feature_group_id: The unique ID associated with the feature group.
      :type feature_group_id: str

      :returns: The project feature group object.
      :rtype: ProjectFeatureGroup



   .. py:method:: list_feature_groups(filter_feature_group_use = None, limit = 100, start_after_id = None)

      List all the feature groups associated with a project

      :param filter_feature_group_use: The feature group use filter, when given as an argument only allows feature groups present in this project to be returned if they are of the given use. Possible values are: 'USER_CREATED', 'BATCH_PREDICTION_OUTPUT'.
      :type filter_feature_group_use: str
      :param limit: The maximum number of feature groups to be retrieved.
      :type limit: int
      :param start_after_id: An offset parameter to exclude all feature groups up to a specified ID.
      :type start_after_id: str

      :returns: All the Feature Groups in a project.
      :rtype: list[ProjectFeatureGroup]



   .. py:method:: list_feature_group_templates(limit = 100, start_after_id = None, should_include_all_system_templates = False)

      List feature group templates for feature groups associated with the project.

      :param limit: Maximum number of templates to be retrieved.
      :type limit: int
      :param start_after_id: Offset parameter to exclude all templates till the specified feature group template ID.
      :type start_after_id: str
      :param should_include_all_system_templates: If True, will include built-in templates.
      :type should_include_all_system_templates: bool

      :returns: All the feature groups in the organization, optionally limited by the feature group that created the template(s).
      :rtype: list[FeatureGroupTemplate]



   .. py:method:: get_training_config_options(feature_group_ids = None, for_retrain = False, current_training_config = None)

      Retrieves the full initial description of the model training configuration options available for the specified project. The configuration options available are determined by the use case associated with the specified project. Refer to the [Use Case Documentation]({USE_CASES_URL}) for more information on use cases and use case-specific configuration options.

      :param feature_group_ids: The feature group IDs to be used for training.
      :type feature_group_ids: List
      :param for_retrain: Whether the training config options are used for retraining.
      :type for_retrain: bool
      :param current_training_config: The current state of the training config, with some options set, which shall be used to get new options after refresh. This is `None` by default initially.
      :type current_training_config: TrainingConfig

      :returns: An array of options that can be specified when training a model in this project.
      :rtype: list[TrainingConfigOptions]



   .. py:method:: create_train_test_data_split_feature_group(training_config, feature_group_ids)

      Get the train and test data split without training the model. Only supported for models with custom algorithms.

      :param training_config: The training config used to influence how the split is calculated.
      :type training_config: TrainingConfig
      :param feature_group_ids: List of feature group IDs provided by the user, including the required one for data split and others to influence how to split.
      :type feature_group_ids: List

      :returns: The feature group containing the training data and folds information.
      :rtype: FeatureGroup



   .. py:method:: train_model(name = None, training_config = None, feature_group_ids = None, refresh_schedule = None, custom_algorithms = None, custom_algorithms_only = False, custom_algorithm_configs = None, builtin_algorithms = None, cpu_size = None, memory = None, algorithm_training_configs = None)

      Create a new model and start its training in the given project.

      :param name: The name of the model. Defaults to "<Project Name> Model".
      :type name: str
      :param training_config: The training config used to train this model.
      :type training_config: TrainingConfig
      :param feature_group_ids: List of feature group IDs provided by the user to train the model on.
      :type feature_group_ids: List
      :param refresh_schedule: A cron-style string that describes a schedule in UTC to automatically retrain the created model.
      :type refresh_schedule: str
      :param custom_algorithms: List of user-defined algorithms to train. If not set, the default enabled custom algorithms will be used.
      :type custom_algorithms: list
      :param custom_algorithms_only: Whether to only run custom algorithms.
      :type custom_algorithms_only: bool
      :param custom_algorithm_configs: Configs for each user-defined algorithm; key is the algorithm name, value is the config serialized to JSON.
      :type custom_algorithm_configs: dict
      :param builtin_algorithms: List of algorithm names or algorithm IDs of the builtin algorithms provided by Abacus.AI to train. If not set, all applicable builtin algorithms will be used.
      :type builtin_algorithms: list
      :param cpu_size: Size of the CPU for the user-defined algorithms during training.
      :type cpu_size: str
      :param memory: Memory (in GB) for the user-defined algorithms during training.
      :type memory: int
      :param algorithm_training_configs: List of algorithm specifc training configs that will be part of the model training AutoML run.
      :type algorithm_training_configs: list

      :returns: The new model which is being trained.
      :rtype: Model



   .. py:method:: create_model_from_python(function_source_code, train_function_name, training_input_tables, predict_function_name = None, predict_many_function_name = None, initialize_function_name = None, name = None, cpu_size = None, memory = None, training_config = None, exclusive_run = False, package_requirements = None, use_gpu = False, is_thread_safe = None)

      Initializes a new Model from user-provided Python code. If a list of input feature groups is supplied, they will be provided as arguments to the train and predict functions with the materialized feature groups for those input feature groups.

      This method expects `functionSourceCode` to be a valid language source file which contains the functions named `trainFunctionName` and `predictFunctionName`. `trainFunctionName` returns the ModelVersion that is the result of training the model using `trainFunctionName` and `predictFunctionName` has no well-defined return type, as it returns the prediction made by the `predictFunctionName`, which can be anything.


      :param function_source_code: Contents of a valid Python source code file. The source code should contain the functions named `trainFunctionName` and `predictFunctionName`. A list of allowed import and system libraries for each language is specified in the user functions documentation section.
      :type function_source_code: str
      :param train_function_name: Name of the function found in the source code that will be executed to train the model. It is not executed when this function is run.
      :type train_function_name: str
      :param training_input_tables: List of feature groups that are supplied to the train function as parameters. Each of the parameters are materialized Dataframes (same type as the functions return value).
      :type training_input_tables: list
      :param predict_function_name: Name of the function found in the source code that will be executed to run predictions through the model. It is not executed when this function is run.
      :type predict_function_name: str
      :param predict_many_function_name: Name of the function found in the source code that will be executed for batch prediction of the model. It is not executed when this function is run.
      :type predict_many_function_name: str
      :param initialize_function_name: Name of the function found in the source code to initialize the trained model before using it to make predictions using the model
      :type initialize_function_name: str
      :param name: The name you want your model to have. Defaults to "<Project Name> Model"
      :type name: str
      :param cpu_size: Size of the CPU for the model training function
      :type cpu_size: str
      :param memory: Memory (in GB) for the model training function
      :type memory: int
      :param training_config: Training configuration
      :type training_config: TrainingConfig
      :param exclusive_run: Decides if this model will be run exclusively or along with other Abacus.AI algorithms
      :type exclusive_run: bool
      :param package_requirements: List of package requirement strings. For example: ['numpy==1.2.3', 'pandas>=1.4.0']
      :type package_requirements: list
      :param use_gpu: Whether this model needs gpu
      :type use_gpu: bool
      :param is_thread_safe: Whether this model is thread safe
      :type is_thread_safe: bool

      :returns: The new model, which has not been trained.
      :rtype: Model



   .. py:method:: list_models()

      Retrieves the list of models in the specified project.

      :param project_id: Unique string identifier associated with the project.
      :type project_id: str

      :returns: A list of models.
      :rtype: list[Model]



   .. py:method:: get_custom_train_function_info(feature_group_names_for_training = None, training_data_parameter_name_override = None, training_config = None, custom_algorithm_config = None)

      Returns information about how to call the custom train function.

      :param feature_group_names_for_training: A list of feature group table names to be used for training.
      :type feature_group_names_for_training: list
      :param training_data_parameter_name_override: Override from feature group type to parameter name in the train function.
      :type training_data_parameter_name_override: dict
      :param training_config: Training config for the options supported by the Abacus.AI platform.
      :type training_config: TrainingConfig
      :param custom_algorithm_config: User-defined config that can be serialized by JSON.
      :type custom_algorithm_config: dict

      :returns: Information about how to call the customer-provided train function.
      :rtype: CustomTrainFunctionInfo



   .. py:method:: create_model_monitor(prediction_feature_group_id, training_feature_group_id = None, name = None, refresh_schedule = None, target_value = None, target_value_bias = None, target_value_performance = None, feature_mappings = None, model_id = None, training_feature_mappings = None, feature_group_base_monitor_config = None, feature_group_comparison_monitor_config = None, exclude_interactive_performance_analysis = True, exclude_bias_analysis = None, exclude_performance_analysis = None, exclude_feature_drift_analysis = None, exclude_data_integrity_analysis = None)

      Runs a model monitor for the specified project.

      :param prediction_feature_group_id: The unique ID of the prediction data feature group.
      :type prediction_feature_group_id: str
      :param training_feature_group_id: The unique ID of the training data feature group.
      :type training_feature_group_id: str
      :param name: The name you want your model monitor to have. Defaults to "<Project Name> Model Monitor".
      :type name: str
      :param refresh_schedule: A cron-style string that describes a schedule in UTC to automatically retrain the created model monitor.
      :type refresh_schedule: str
      :param target_value: A target positive value for the label to compute bias and PR/AUC for performance page.
      :type target_value: str
      :param target_value_bias: A target positive value for the label to compute bias.
      :type target_value_bias: str
      :param target_value_performance: A target positive value for the label to compute PR curve/AUC for performance page.
      :type target_value_performance: str
      :param feature_mappings: A JSON map to override features for prediction_feature_group, where keys are column names and the values are feature data use types.
      :type feature_mappings: dict
      :param model_id: The unique ID of the model.
      :type model_id: str
      :param training_feature_mappings: A JSON map to override features for training_fature_group, where keys are column names and the values are feature data use types.
      :type training_feature_mappings: dict
      :param feature_group_base_monitor_config: Selection strategy for the feature_group 1 with the feature group version if selected.
      :type feature_group_base_monitor_config: dict
      :param feature_group_comparison_monitor_config: Selection strategy for the feature_group 1 with the feature group version if selected.
      :type feature_group_comparison_monitor_config: dict
      :param exclude_interactive_performance_analysis: Whether to exclude interactive performance analysis. Defaults to True if not provided.
      :type exclude_interactive_performance_analysis: bool
      :param exclude_bias_analysis: Whether to exclude bias analysis in the model monitor. For default value bias analysis is included.
      :type exclude_bias_analysis: bool
      :param exclude_performance_analysis: Whether to exclude performance analysis in the model monitor. For default value performance analysis is included.
      :type exclude_performance_analysis: bool
      :param exclude_feature_drift_analysis: Whether to exclude feature drift analysis in the model monitor. For default value feature drift analysis is included.
      :type exclude_feature_drift_analysis: bool
      :param exclude_data_integrity_analysis: Whether to exclude data integrity analysis in the model monitor. For default value data integrity analysis is included.
      :type exclude_data_integrity_analysis: bool

      :returns: The new model monitor that was created.
      :rtype: ModelMonitor



   .. py:method:: list_model_monitors()

      Retrieves the list of model monitors in the specified project.

      :param project_id: Unique string identifier associated with the project.
      :type project_id: str

      :returns: A list of model monitors.
      :rtype: list[ModelMonitor]



   .. py:method:: create_vision_drift_monitor(prediction_feature_group_id, training_feature_group_id, name, feature_mappings, training_feature_mappings, target_value_performance = None, refresh_schedule = None)

      Runs a vision drift monitor for the specified project.

      :param prediction_feature_group_id: Unique string identifier of the prediction data feature group.
      :type prediction_feature_group_id: str
      :param training_feature_group_id: Unique string identifier of the training data feature group.
      :type training_feature_group_id: str
      :param name: The name you want your model monitor to have. Defaults to "<Project Name> Model Monitor".
      :type name: str
      :param feature_mappings: A JSON map to override features for prediction_feature_group, where keys are column names and the values are feature data use types.
      :type feature_mappings: dict
      :param training_feature_mappings: A JSON map to override features for training_feature_group, where keys are column names and the values are feature data use types.
      :type training_feature_mappings: dict
      :param target_value_performance: A target positive value for the label to compute precision-recall curve/area under curve for performance page.
      :type target_value_performance: str
      :param refresh_schedule: A cron-style string that describes a schedule in UTC to automatically rerun the created vision drift monitor.
      :type refresh_schedule: str

      :returns: The new model monitor that was created.
      :rtype: ModelMonitor



   .. py:method:: create_nlp_drift_monitor(prediction_feature_group_id, training_feature_group_id, name, feature_mappings, training_feature_mappings, target_value_performance = None, refresh_schedule = None)

      Runs an NLP drift monitor for the specified project.

      :param prediction_feature_group_id: Unique string identifier of the prediction data feature group.
      :type prediction_feature_group_id: str
      :param training_feature_group_id: Unique string identifier of the training data feature group.
      :type training_feature_group_id: str
      :param name: The name you want your model monitor to have. Defaults to "<Project Name> Model Monitor".
      :type name: str
      :param feature_mappings: A JSON map to override features for prediction_feature_group, where keys are column names and the values are feature data use types.
      :type feature_mappings: dict
      :param training_feature_mappings: A JSON map to override features for training_feature_group, where keys are column names and the values are feature data use types.
      :type training_feature_mappings: dict
      :param target_value_performance: A target positive value for the label to compute precision-recall curve/area under curve for performance page.
      :type target_value_performance: str
      :param refresh_schedule: A cron-style string that describes a schedule in UTC to automatically rerun the created nlp drift monitor.
      :type refresh_schedule: str

      :returns: The new model monitor that was created.
      :rtype: ModelMonitor



   .. py:method:: create_forecasting_monitor(name, prediction_feature_group_id, training_feature_group_id, training_forecast_config, prediction_forecast_config, forecast_frequency, refresh_schedule = None)

      Runs a forecasting monitor for the specified project.

      :param name: The name you want your model monitor to have. Defaults to "<Project Name> Model Monitor".
      :type name: str
      :param prediction_feature_group_id: Unique string identifier of the prediction data feature group.
      :type prediction_feature_group_id: str
      :param training_feature_group_id: Unique string identifier of the training data feature group.
      :type training_feature_group_id: str
      :param training_forecast_config: The configuration for the training data.
      :type training_forecast_config: ForecastingMonitorConfig
      :param prediction_forecast_config: The configuration for the prediction data.
      :type prediction_forecast_config: ForecastingMonitorConfig
      :param forecast_frequency: The frequency of the forecast. Defaults to the frequency of the prediction data.
      :type forecast_frequency: str
      :param refresh_schedule: A cron-style string that describes a schedule in UTC to automatically rerun the created forecasting monitor.
      :type refresh_schedule: str

      :returns: The new model monitor that was created.
      :rtype: ModelMonitor



   .. py:method:: create_eda(feature_group_id, name, refresh_schedule = None, include_collinearity = False, include_data_consistency = False, collinearity_keys = None, primary_keys = None, data_consistency_test_config = None, data_consistency_reference_config = None, feature_mappings = None, forecast_frequency = None)

      Run an Exploratory Data Analysis (EDA) for the specified project.

      :param feature_group_id: The unique ID of the prediction data feature group.
      :type feature_group_id: str
      :param name: The name you want your model monitor to have. Defaults to "<Project Name> EDA".
      :type name: str
      :param refresh_schedule: A cron-style string that describes a schedule in UTC to automatically retrain the created EDA.
      :type refresh_schedule: str
      :param include_collinearity: Set to True if the EDA type is collinearity.
      :type include_collinearity: bool
      :param include_data_consistency: Set to True if the EDA type is data consistency.
      :type include_data_consistency: bool
      :param collinearity_keys: List of features to use for collinearity
      :type collinearity_keys: list
      :param primary_keys: List of features that corresponds to the primary keys or item ids for the given feature group for Data Consistency analysis or Forecasting analysis respectively.
      :type primary_keys: list
      :param data_consistency_test_config: Test feature group version selection strategy for Data Consistency EDA type.
      :type data_consistency_test_config: dict
      :param data_consistency_reference_config: Reference feature group version selection strategy for Data Consistency EDA type.
      :type data_consistency_reference_config: dict
      :param feature_mappings: A JSON map to override features for the given feature_group, where keys are column names and the values are feature data use types. (In forecasting, used to set the timestamp column and target value)
      :type feature_mappings: dict
      :param forecast_frequency: The frequency of the data. It can be either HOURLY, DAILY, WEEKLY, MONTHLY, QUARTERLY, YEARLY.
      :type forecast_frequency: str

      :returns: The new EDA object that was created.
      :rtype: Eda



   .. py:method:: list_eda()

      Retrieves the list of Exploratory Data Analysis (EDA) in the specified project.

      :param project_id: Unique string identifier associated with the project.
      :type project_id: str

      :returns: List of EDA objects.
      :rtype: list[Eda]



   .. py:method:: list_holdout_analysis(model_id = None)

      List holdout analyses for a project. Optionally, filter by model.

      :param model_id: (optional) ID of the model to filter by
      :type model_id: str

      :returns: The holdout analyses
      :rtype: list[HoldoutAnalysis]



   .. py:method:: create_monitor_alert(alert_name, condition_config, action_config, model_monitor_id = None, realtime_monitor_id = None)

      Create a monitor alert for the given conditions and monitor. We can create monitor alert either for model monitor or real-time monitor.

      :param alert_name: Name of the alert.
      :type alert_name: str
      :param condition_config: Condition to run the actions for the alert.
      :type condition_config: AlertConditionConfig
      :param action_config: Configuration for the action of the alert.
      :type action_config: AlertActionConfig
      :param model_monitor_id: Unique string identifier for the model monitor created under the project.
      :type model_monitor_id: str
      :param realtime_monitor_id: Unique string identifier for the real-time monitor for the deployment created under the project.
      :type realtime_monitor_id: str

      :returns: Object describing the monitor alert.
      :rtype: MonitorAlert



   .. py:method:: list_prediction_operators()

      List all the prediction operators inside a project.

      :param project_id: The unique ID of the project.
      :type project_id: str

      :returns: A list of prediction operator objects.
      :rtype: list[PredictionOperator]



   .. py:method:: create_deployment_token(name = None)

      Creates a deployment token for the specified project.

      Deployment tokens are used to authenticate requests to the prediction APIs and are scoped to the project level.


      :param name: The name of the deployment token.
      :type name: str

      :returns: The deployment token.
      :rtype: DeploymentAuthToken



   .. py:method:: list_deployments()

      Retrieves a list of all deployments in the specified project.

      :param project_id: The unique identifier associated with the project.
      :type project_id: str

      :returns: An array of deployments.
      :rtype: list[Deployment]



   .. py:method:: list_deployment_tokens()

      Retrieves a list of all deployment tokens associated with the specified project.

      :param project_id: The unique ID associated with the project.
      :type project_id: str

      :returns: A list of deployment tokens.
      :rtype: list[DeploymentAuthToken]



   .. py:method:: list_realtime_monitors()

      List the real-time monitors associated with the deployment id.

      :param project_id: Unique string identifier for the deployment.
      :type project_id: str

      :returns: An array of real-time monitors.
      :rtype: list[RealtimeMonitor]



   .. py:method:: list_refresh_policies(dataset_ids = [], feature_group_id = None, model_ids = [], deployment_ids = [], batch_prediction_ids = [], model_monitor_ids = [], notebook_ids = [])

      List the refresh policies for the organization. If no filters are specified, all refresh policies are returned.

      :param dataset_ids: Comma-separated list of Dataset IDs.
      :type dataset_ids: List
      :param feature_group_id: Feature Group ID for which we wish to see the refresh policies attached.
      :type feature_group_id: str
      :param model_ids: Comma-separated list of Model IDs.
      :type model_ids: List
      :param deployment_ids: Comma-separated list of Deployment IDs.
      :type deployment_ids: List
      :param batch_prediction_ids: Comma-separated list of Batch Prediction IDs.
      :type batch_prediction_ids: List
      :param model_monitor_ids: Comma-separated list of Model Monitor IDs.
      :type model_monitor_ids: List
      :param notebook_ids: Comma-separated list of Notebook IDs.
      :type notebook_ids: List

      :returns: List of all refresh policies in the organization.
      :rtype: list[RefreshPolicy]



   .. py:method:: list_batch_predictions()

      Retrieves a list of batch predictions in the project.

      :param project_id: Unique string identifier of the project.
      :type project_id: str

      :returns: List of batch prediction jobs.
      :rtype: list[BatchPrediction]



   .. py:method:: list_pipelines()

      Lists the pipelines for an organization or a project

      :param project_id: Unique string identifier for the project to list graph dashboards from.
      :type project_id: str

      :returns: A list of pipelines.
      :rtype: list[Pipeline]



   .. py:method:: create_graph_dashboard(name, python_function_ids = None)

      Create a plot dashboard given selected python plots

      :param name: The name of the dashboard.
      :type name: str
      :param python_function_ids: A list of unique string identifiers for the python functions to be used in the graph dashboard.
      :type python_function_ids: List

      :returns: An object describing the graph dashboard.
      :rtype: GraphDashboard



   .. py:method:: list_graph_dashboards()

      Lists the graph dashboards for a project

      :param project_id: Unique string identifier for the project to list graph dashboards from.
      :type project_id: str

      :returns: A list of graph dashboards.
      :rtype: list[GraphDashboard]



   .. py:method:: list_builtin_algorithms(feature_group_ids, training_config = None)

      Return list of built-in algorithms based on given input data and training config.

      :param feature_group_ids: List of feature group IDs specifying input data.
      :type feature_group_ids: List
      :param training_config: The training config to be used for model training.
      :type training_config: TrainingConfig

      :returns: List of applicable builtin algorithms.
      :rtype: list[Algorithm]



   .. py:method:: create_chat_session(name = None)

      Creates a chat session with Data Science Co-pilot.

      :param name: The name of the chat session. Defaults to the project name.
      :type name: str

      :returns: The chat session with Data Science Co-pilot
      :rtype: ChatSession



   .. py:method:: create_agent(function_source_code = None, agent_function_name = None, name = None, memory = None, package_requirements = None, description = None, enable_binary_input = False, evaluation_feature_group_id = None, agent_input_schema = None, agent_output_schema = None, workflow_graph = None, agent_interface = AgentInterface.DEFAULT)

      Creates a new AI agent using the given agent workflow graph definition.

      :param name: The name you want your agent to have, defaults to "<Project Name> Agent".
      :type name: str
      :param memory: Overrides the default memory allocation (in GB) for the agent.
      :type memory: int
      :param description: A description of the agent, including its purpose and instructions.
      :type description: str
      :param evaluation_feature_group_id: The ID of the feature group to use for evaluation.
      :type evaluation_feature_group_id: str
      :param workflow_graph: The workflow graph for the agent.
      :type workflow_graph: WorkflowGraph
      :param agent_interface: The interface that the agent will be deployed with.
      :type agent_interface: AgentInterface

      :returns: The new agent.
      :rtype: Agent



   .. py:method:: list_agents()

      Retrieves the list of agents in the specified project.

      :param project_id: The unique identifier associated with the project.
      :type project_id: str

      :returns: A list of agents in the project.
      :rtype: list[Agent]



   .. py:method:: create_document_retriever(name, feature_group_id, document_retriever_config = None)

      Returns a document retriever that stores embeddings for document chunks in a feature group.

      Document columns in the feature group are broken into chunks. For cases with multiple document columns, chunks from all columns are combined together to form a single chunk.


      :param name: The name of the Document Retriever. Can be up to 120 characters long and can only contain alphanumeric characters and underscores.
      :type name: str
      :param feature_group_id: The ID of the feature group that the Document Retriever is associated with.
      :type feature_group_id: str
      :param document_retriever_config: The configuration, including chunk_size and chunk_overlap_fraction, for document retrieval.
      :type document_retriever_config: VectorStoreConfig

      :returns: The newly created document retriever.
      :rtype: DocumentRetriever



   .. py:method:: list_document_retrievers(limit = 100, start_after_id = None)

      List all the document retrievers.

      :param limit: The number of document retrievers to return.
      :type limit: int
      :param start_after_id: An offset parameter to exclude all document retrievers up to this specified ID.
      :type start_after_id: str

      :returns: All the document retrievers in the organization associated with the specified project.
      :rtype: list[DocumentRetriever]



   .. py:method:: create_model_from_functions(train_function, predict_function = None, training_input_tables = None, predict_many_function = None, initialize_function = None, cpu_size = None, memory = None, training_config = None, exclusive_run = False)

      Creates a model using python.

      :param train_function: The train function is passed.
      :type train_function: callable
      :param predict_function: The prediction function is passed.
      :type predict_function: callable
      :param training_input_tables: The input tables to be used for training the model. Defaults to None.
      :type training_input_tables: list
      :param predict_many_function: Prediction function for batch input
      :type predict_many_function: callable
      :param cpu_size: Size of the cpu for the feature group function
      :type cpu_size: str
      :param memory: Memory (in GB) for the feature group function
      :type memory: int

      :returns: The model object.
      :rtype: Model



