diff --git a/x-pack/plugin/core/src/main/java/module-info.java b/x-pack/plugin/core/src/main/java/module-info.java index 83c8e780106a9..bb183f8d3845e 100644 --- a/x-pack/plugin/core/src/main/java/module-info.java +++ b/x-pack/plugin/core/src/main/java/module-info.java @@ -237,6 +237,7 @@ exports org.elasticsearch.xpack.core.watcher.watch; exports org.elasticsearch.xpack.core.watcher; exports org.elasticsearch.xpack.core.common.chunks; + exports org.elasticsearch.xpack.core.inference.chunking; provides org.elasticsearch.action.admin.cluster.node.info.ComponentVersionNumber with diff --git a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/XPackClientPlugin.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/XPackClientPlugin.java index da235b7936270..e5ce1bb051b83 100644 --- a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/XPackClientPlugin.java +++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/XPackClientPlugin.java @@ -12,6 +12,7 @@ import org.elasticsearch.common.io.stream.NamedWriteableRegistry; import org.elasticsearch.common.settings.Setting; import org.elasticsearch.index.query.QueryBuilder; +import org.elasticsearch.inference.ChunkingSettings; import org.elasticsearch.license.LicensesMetadata; import org.elasticsearch.persistent.PersistentTaskParams; import org.elasticsearch.persistent.PersistentTaskState; @@ -59,6 +60,10 @@ import org.elasticsearch.xpack.core.ilm.UnfollowAction; import org.elasticsearch.xpack.core.ilm.WaitForSnapshotAction; import org.elasticsearch.xpack.core.inference.InferenceFeatureSetUsage; +import org.elasticsearch.xpack.core.inference.chunking.NoneChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.RecursiveChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.SentenceBoundaryChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.WordBoundaryChunkingSettings; import org.elasticsearch.xpack.core.logstash.LogstashFeatureSetUsage; import org.elasticsearch.xpack.core.ml.MachineLearningFeatureSetUsage; import org.elasticsearch.xpack.core.ml.MlMetadata; @@ -137,184 +142,219 @@ public List> getSettings() { @Override public List getNamedWriteables() { - return Stream.of( - // graph - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.GRAPH, GraphFeatureSetUsage::new), - // logstash - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.LOGSTASH, LogstashFeatureSetUsage::new), - // ML - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.MACHINE_LEARNING, MachineLearningFeatureSetUsage::new), - // inference - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.INFERENCE, InferenceFeatureSetUsage::new), - // monitoring - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.MONITORING, MonitoringFeatureSetUsage::new), - // security - new NamedWriteableRegistry.Entry(ClusterState.Custom.class, TokenMetadata.TYPE, TokenMetadata::new), - new NamedWriteableRegistry.Entry(NamedDiff.class, TokenMetadata.TYPE, TokenMetadata::readDiffFrom), - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.SECURITY, SecurityFeatureSetUsage::new), - // security : configurable cluster privileges - new NamedWriteableRegistry.Entry( - ConfigurableClusterPrivilege.class, - ConfigurableClusterPrivileges.ManageApplicationPrivileges.WRITEABLE_NAME, - ConfigurableClusterPrivileges.ManageApplicationPrivileges::createFrom - ), - new NamedWriteableRegistry.Entry( - ConfigurableClusterPrivilege.class, - ConfigurableClusterPrivileges.WriteProfileDataPrivileges.WRITEABLE_NAME, - ConfigurableClusterPrivileges.WriteProfileDataPrivileges::createFrom - ), - new NamedWriteableRegistry.Entry( - ConfigurableClusterPrivilege.class, - ConfigurableClusterPrivileges.ManageRolesPrivilege.WRITEABLE_NAME, - ConfigurableClusterPrivileges.ManageRolesPrivilege::createFrom - ), - // security : role-mappings - new NamedWriteableRegistry.Entry(Metadata.ProjectCustom.class, RoleMappingMetadata.TYPE, RoleMappingMetadata::new), - new NamedWriteableRegistry.Entry(NamedDiff.class, RoleMappingMetadata.TYPE, RoleMappingMetadata::readDiffFrom), - new NamedWriteableRegistry.Entry(RoleMapperExpression.class, AllExpression.NAME, AllExpression::new), - new NamedWriteableRegistry.Entry(RoleMapperExpression.class, AnyExpression.NAME, AnyExpression::new), - new NamedWriteableRegistry.Entry(RoleMapperExpression.class, FieldExpression.NAME, FieldExpression::new), - new NamedWriteableRegistry.Entry(RoleMapperExpression.class, ExceptExpression.NAME, ExceptExpression::new), - // security : role descriptors - new NamedWriteableRegistry.Entry(RemoteClusterPermissions.class, RemoteClusterPermissions.NAME, RemoteClusterPermissions::new), - new NamedWriteableRegistry.Entry( - RemoteClusterPermissionGroup.class, - RemoteClusterPermissionGroup.NAME, - RemoteClusterPermissionGroup::new - ), - // eql - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.EQL, EqlFeatureSetUsage::new), - // esql - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.ESQL, EsqlFeatureSetUsage::new), - // sql - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.SQL, SqlFeatureSetUsage::new), - // watcher - new NamedWriteableRegistry.Entry(Metadata.ProjectCustom.class, WatcherMetadata.TYPE, WatcherMetadata::new), - new NamedWriteableRegistry.Entry(NamedDiff.class, WatcherMetadata.TYPE, WatcherMetadata::readDiffFrom), - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.WATCHER, WatcherFeatureSetUsage::new), - // licensing - new NamedWriteableRegistry.Entry(Metadata.ClusterCustom.class, LicensesMetadata.TYPE, LicensesMetadata::new), - new NamedWriteableRegistry.Entry(NamedDiff.class, LicensesMetadata.TYPE, LicensesMetadata::readDiffFrom), - // rollup - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.ROLLUP, RollupFeatureSetUsage::new), - new NamedWriteableRegistry.Entry(PersistentTaskParams.class, RollupJob.NAME, RollupJob::new), - new NamedWriteableRegistry.Entry(Task.Status.class, RollupJobStatus.NAME, RollupJobStatus::new), - new NamedWriteableRegistry.Entry(PersistentTaskState.class, RollupJobStatus.NAME, RollupJobStatus::new), - new NamedWriteableRegistry.Entry(Task.Status.class, DownsampleShardStatus.NAME, DownsampleShardStatus::new), - // ccr - new NamedWriteableRegistry.Entry(AutoFollowMetadata.class, AutoFollowMetadata.TYPE, AutoFollowMetadata::new), - new NamedWriteableRegistry.Entry(Metadata.ProjectCustom.class, AutoFollowMetadata.TYPE, AutoFollowMetadata::new), - new NamedWriteableRegistry.Entry( - NamedDiff.class, - AutoFollowMetadata.TYPE, - in -> AutoFollowMetadata.readDiffFrom(Metadata.ProjectCustom.class, AutoFollowMetadata.TYPE, in) - ), - // ILM - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.INDEX_LIFECYCLE, IndexLifecycleFeatureSetUsage::new), - // SLM - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.SNAPSHOT_LIFECYCLE, SLMFeatureSetUsage::new), - // ILM - Custom Metadata - new NamedWriteableRegistry.Entry(Metadata.ProjectCustom.class, IndexLifecycleMetadata.TYPE, IndexLifecycleMetadata::new), - new NamedWriteableRegistry.Entry( - NamedDiff.class, - IndexLifecycleMetadata.TYPE, - IndexLifecycleMetadata.IndexLifecycleMetadataDiff::new - ), - new NamedWriteableRegistry.Entry( - Metadata.ProjectCustom.class, - LifecycleOperationMetadata.TYPE, - LifecycleOperationMetadata::new - ), - new NamedWriteableRegistry.Entry( - NamedDiff.class, - LifecycleOperationMetadata.TYPE, - LifecycleOperationMetadata.LifecycleOperationMetadataDiff::new - ), - new NamedWriteableRegistry.Entry(Metadata.ProjectCustom.class, SnapshotLifecycleMetadata.TYPE, SnapshotLifecycleMetadata::new), - new NamedWriteableRegistry.Entry( - NamedDiff.class, - SnapshotLifecycleMetadata.TYPE, - SnapshotLifecycleMetadata.SnapshotLifecycleMetadataDiff::new - ), - // ILM - LifecycleTypes - new NamedWriteableRegistry.Entry(LifecycleType.class, TimeseriesLifecycleType.TYPE, (in) -> TimeseriesLifecycleType.INSTANCE), - // ILM - Lifecycle Actions - new NamedWriteableRegistry.Entry(LifecycleAction.class, AllocateAction.NAME, AllocateAction::new), - new NamedWriteableRegistry.Entry(LifecycleAction.class, ForceMergeAction.NAME, ForceMergeAction::new), - new NamedWriteableRegistry.Entry(LifecycleAction.class, ReadOnlyAction.NAME, ReadOnlyAction::new), - new NamedWriteableRegistry.Entry(LifecycleAction.class, RolloverAction.NAME, RolloverAction::read), - new NamedWriteableRegistry.Entry(LifecycleAction.class, ShrinkAction.NAME, ShrinkAction::new), - new NamedWriteableRegistry.Entry(LifecycleAction.class, DeleteAction.NAME, DeleteAction::readFrom), - new NamedWriteableRegistry.Entry(LifecycleAction.class, FreezeAction.NAME, in -> FreezeAction.INSTANCE), - new NamedWriteableRegistry.Entry(LifecycleAction.class, SetPriorityAction.NAME, SetPriorityAction::new), - new NamedWriteableRegistry.Entry(LifecycleAction.class, UnfollowAction.NAME, in -> UnfollowAction.INSTANCE), - new NamedWriteableRegistry.Entry(LifecycleAction.class, WaitForSnapshotAction.NAME, WaitForSnapshotAction::new), - new NamedWriteableRegistry.Entry(LifecycleAction.class, SearchableSnapshotAction.NAME, SearchableSnapshotAction::new), - new NamedWriteableRegistry.Entry(LifecycleAction.class, MigrateAction.NAME, MigrateAction::readFrom), - // Transforms - new NamedWriteableRegistry.Entry(Metadata.ProjectCustom.class, TransformMetadata.TYPE, TransformMetadata::new), - new NamedWriteableRegistry.Entry(NamedDiff.class, TransformMetadata.TYPE, TransformMetadata.TransformMetadataDiff::new), - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.TRANSFORM, TransformFeatureSetUsage::new), - new NamedWriteableRegistry.Entry(PersistentTaskParams.class, TransformField.TASK_NAME, TransformTaskParams::new), - new NamedWriteableRegistry.Entry(Task.Status.class, TransformField.TASK_NAME, TransformState::new), - new NamedWriteableRegistry.Entry(PersistentTaskState.class, TransformField.TASK_NAME, TransformState::new), - new NamedWriteableRegistry.Entry(SyncConfig.class, TransformField.TIME.getPreferredName(), TimeSyncConfig::new), - new NamedWriteableRegistry.Entry( - RetentionPolicyConfig.class, - TransformField.TIME.getPreferredName(), - TimeRetentionPolicyConfig::new - ), - new NamedWriteableRegistry.Entry( - RetentionPolicyConfig.class, - NullRetentionPolicyConfig.NAME.getPreferredName(), - i -> NullRetentionPolicyConfig.INSTANCE - ), - // Voting Only Node - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.VOTING_ONLY, VotingOnlyNodeFeatureSetUsage::new), - // Frozen indices - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.FROZEN_INDICES, FrozenIndicesFeatureSetUsage::new), - // Spatial - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.SPATIAL, SpatialFeatureSetUsage::new), - // Analytics - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.ANALYTICS, AnalyticsFeatureSetUsage::new), - // Aggregate metric field type - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.AGGREGATE_METRIC, AggregateMetricFeatureSetUsage::new), - // Enrich - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.ENRICH, EnrichFeatureSetUsage::new), - new NamedWriteableRegistry.Entry(Task.Status.class, ExecuteEnrichPolicyStatus.NAME, ExecuteEnrichPolicyStatus::new), - // Searchable snapshots - new NamedWriteableRegistry.Entry( - XPackFeatureUsage.class, - XPackField.SEARCHABLE_SNAPSHOTS, - SearchableSnapshotFeatureSetUsage::new + return Stream.concat( + Stream.of( + // graph + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.GRAPH, GraphFeatureSetUsage::new), + // logstash + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.LOGSTASH, LogstashFeatureSetUsage::new), + // ML + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.MACHINE_LEARNING, MachineLearningFeatureSetUsage::new), + // inference + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.INFERENCE, InferenceFeatureSetUsage::new), + // monitoring + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.MONITORING, MonitoringFeatureSetUsage::new), + // security + new NamedWriteableRegistry.Entry(ClusterState.Custom.class, TokenMetadata.TYPE, TokenMetadata::new), + new NamedWriteableRegistry.Entry(NamedDiff.class, TokenMetadata.TYPE, TokenMetadata::readDiffFrom), + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.SECURITY, SecurityFeatureSetUsage::new), + // security : configurable cluster privileges + new NamedWriteableRegistry.Entry( + ConfigurableClusterPrivilege.class, + ConfigurableClusterPrivileges.ManageApplicationPrivileges.WRITEABLE_NAME, + ConfigurableClusterPrivileges.ManageApplicationPrivileges::createFrom + ), + new NamedWriteableRegistry.Entry( + ConfigurableClusterPrivilege.class, + ConfigurableClusterPrivileges.WriteProfileDataPrivileges.WRITEABLE_NAME, + ConfigurableClusterPrivileges.WriteProfileDataPrivileges::createFrom + ), + new NamedWriteableRegistry.Entry( + ConfigurableClusterPrivilege.class, + ConfigurableClusterPrivileges.ManageRolesPrivilege.WRITEABLE_NAME, + ConfigurableClusterPrivileges.ManageRolesPrivilege::createFrom + ), + // security : role-mappings + new NamedWriteableRegistry.Entry(Metadata.ProjectCustom.class, RoleMappingMetadata.TYPE, RoleMappingMetadata::new), + new NamedWriteableRegistry.Entry(NamedDiff.class, RoleMappingMetadata.TYPE, RoleMappingMetadata::readDiffFrom), + new NamedWriteableRegistry.Entry(RoleMapperExpression.class, AllExpression.NAME, AllExpression::new), + new NamedWriteableRegistry.Entry(RoleMapperExpression.class, AnyExpression.NAME, AnyExpression::new), + new NamedWriteableRegistry.Entry(RoleMapperExpression.class, FieldExpression.NAME, FieldExpression::new), + new NamedWriteableRegistry.Entry(RoleMapperExpression.class, ExceptExpression.NAME, ExceptExpression::new), + // security : role descriptors + new NamedWriteableRegistry.Entry( + RemoteClusterPermissions.class, + RemoteClusterPermissions.NAME, + RemoteClusterPermissions::new + ), + new NamedWriteableRegistry.Entry( + RemoteClusterPermissionGroup.class, + RemoteClusterPermissionGroup.NAME, + RemoteClusterPermissionGroup::new + ), + // eql + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.EQL, EqlFeatureSetUsage::new), + // esql + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.ESQL, EsqlFeatureSetUsage::new), + // sql + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.SQL, SqlFeatureSetUsage::new), + // watcher + new NamedWriteableRegistry.Entry(Metadata.ProjectCustom.class, WatcherMetadata.TYPE, WatcherMetadata::new), + new NamedWriteableRegistry.Entry(NamedDiff.class, WatcherMetadata.TYPE, WatcherMetadata::readDiffFrom), + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.WATCHER, WatcherFeatureSetUsage::new), + // licensing + new NamedWriteableRegistry.Entry(Metadata.ClusterCustom.class, LicensesMetadata.TYPE, LicensesMetadata::new), + new NamedWriteableRegistry.Entry(NamedDiff.class, LicensesMetadata.TYPE, LicensesMetadata::readDiffFrom), + // rollup + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.ROLLUP, RollupFeatureSetUsage::new), + new NamedWriteableRegistry.Entry(PersistentTaskParams.class, RollupJob.NAME, RollupJob::new), + new NamedWriteableRegistry.Entry(Task.Status.class, RollupJobStatus.NAME, RollupJobStatus::new), + new NamedWriteableRegistry.Entry(PersistentTaskState.class, RollupJobStatus.NAME, RollupJobStatus::new), + new NamedWriteableRegistry.Entry(Task.Status.class, DownsampleShardStatus.NAME, DownsampleShardStatus::new), + // ccr + new NamedWriteableRegistry.Entry(AutoFollowMetadata.class, AutoFollowMetadata.TYPE, AutoFollowMetadata::new), + new NamedWriteableRegistry.Entry(Metadata.ProjectCustom.class, AutoFollowMetadata.TYPE, AutoFollowMetadata::new), + new NamedWriteableRegistry.Entry( + NamedDiff.class, + AutoFollowMetadata.TYPE, + in -> AutoFollowMetadata.readDiffFrom(Metadata.ProjectCustom.class, AutoFollowMetadata.TYPE, in) + ), + // ILM + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.INDEX_LIFECYCLE, IndexLifecycleFeatureSetUsage::new), + // SLM + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.SNAPSHOT_LIFECYCLE, SLMFeatureSetUsage::new), + // ILM - Custom Metadata + new NamedWriteableRegistry.Entry(Metadata.ProjectCustom.class, IndexLifecycleMetadata.TYPE, IndexLifecycleMetadata::new), + new NamedWriteableRegistry.Entry( + NamedDiff.class, + IndexLifecycleMetadata.TYPE, + IndexLifecycleMetadata.IndexLifecycleMetadataDiff::new + ), + new NamedWriteableRegistry.Entry( + Metadata.ProjectCustom.class, + LifecycleOperationMetadata.TYPE, + LifecycleOperationMetadata::new + ), + new NamedWriteableRegistry.Entry( + NamedDiff.class, + LifecycleOperationMetadata.TYPE, + LifecycleOperationMetadata.LifecycleOperationMetadataDiff::new + ), + new NamedWriteableRegistry.Entry( + Metadata.ProjectCustom.class, + SnapshotLifecycleMetadata.TYPE, + SnapshotLifecycleMetadata::new + ), + new NamedWriteableRegistry.Entry( + NamedDiff.class, + SnapshotLifecycleMetadata.TYPE, + SnapshotLifecycleMetadata.SnapshotLifecycleMetadataDiff::new + ), + // ILM - LifecycleTypes + new NamedWriteableRegistry.Entry( + LifecycleType.class, + TimeseriesLifecycleType.TYPE, + (in) -> TimeseriesLifecycleType.INSTANCE + ), + // ILM - Lifecycle Actions + new NamedWriteableRegistry.Entry(LifecycleAction.class, AllocateAction.NAME, AllocateAction::new), + new NamedWriteableRegistry.Entry(LifecycleAction.class, ForceMergeAction.NAME, ForceMergeAction::new), + new NamedWriteableRegistry.Entry(LifecycleAction.class, ReadOnlyAction.NAME, ReadOnlyAction::new), + new NamedWriteableRegistry.Entry(LifecycleAction.class, RolloverAction.NAME, RolloverAction::read), + new NamedWriteableRegistry.Entry(LifecycleAction.class, ShrinkAction.NAME, ShrinkAction::new), + new NamedWriteableRegistry.Entry(LifecycleAction.class, DeleteAction.NAME, DeleteAction::readFrom), + new NamedWriteableRegistry.Entry(LifecycleAction.class, FreezeAction.NAME, in -> FreezeAction.INSTANCE), + new NamedWriteableRegistry.Entry(LifecycleAction.class, SetPriorityAction.NAME, SetPriorityAction::new), + new NamedWriteableRegistry.Entry(LifecycleAction.class, UnfollowAction.NAME, in -> UnfollowAction.INSTANCE), + new NamedWriteableRegistry.Entry(LifecycleAction.class, WaitForSnapshotAction.NAME, WaitForSnapshotAction::new), + new NamedWriteableRegistry.Entry(LifecycleAction.class, SearchableSnapshotAction.NAME, SearchableSnapshotAction::new), + new NamedWriteableRegistry.Entry(LifecycleAction.class, MigrateAction.NAME, MigrateAction::readFrom), + // Transforms + new NamedWriteableRegistry.Entry(Metadata.ProjectCustom.class, TransformMetadata.TYPE, TransformMetadata::new), + new NamedWriteableRegistry.Entry(NamedDiff.class, TransformMetadata.TYPE, TransformMetadata.TransformMetadataDiff::new), + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.TRANSFORM, TransformFeatureSetUsage::new), + new NamedWriteableRegistry.Entry(PersistentTaskParams.class, TransformField.TASK_NAME, TransformTaskParams::new), + new NamedWriteableRegistry.Entry(Task.Status.class, TransformField.TASK_NAME, TransformState::new), + new NamedWriteableRegistry.Entry(PersistentTaskState.class, TransformField.TASK_NAME, TransformState::new), + new NamedWriteableRegistry.Entry(SyncConfig.class, TransformField.TIME.getPreferredName(), TimeSyncConfig::new), + new NamedWriteableRegistry.Entry( + RetentionPolicyConfig.class, + TransformField.TIME.getPreferredName(), + TimeRetentionPolicyConfig::new + ), + new NamedWriteableRegistry.Entry( + RetentionPolicyConfig.class, + NullRetentionPolicyConfig.NAME.getPreferredName(), + i -> NullRetentionPolicyConfig.INSTANCE + ), + // Voting Only Node + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.VOTING_ONLY, VotingOnlyNodeFeatureSetUsage::new), + // Frozen indices + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.FROZEN_INDICES, FrozenIndicesFeatureSetUsage::new), + // Spatial + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.SPATIAL, SpatialFeatureSetUsage::new), + // Analytics + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.ANALYTICS, AnalyticsFeatureSetUsage::new), + // Aggregate metric field type + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.AGGREGATE_METRIC, AggregateMetricFeatureSetUsage::new), + // Enrich + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.ENRICH, EnrichFeatureSetUsage::new), + new NamedWriteableRegistry.Entry(Task.Status.class, ExecuteEnrichPolicyStatus.NAME, ExecuteEnrichPolicyStatus::new), + // Searchable snapshots + new NamedWriteableRegistry.Entry( + XPackFeatureUsage.class, + XPackField.SEARCHABLE_SNAPSHOTS, + SearchableSnapshotFeatureSetUsage::new + ), + // Data Streams + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.DATA_STREAMS, DataStreamFeatureSetUsage::new), + new NamedWriteableRegistry.Entry( + XPackFeatureUsage.class, + XPackField.DATA_STREAM_LIFECYCLE, + DataStreamLifecycleFeatureSetUsage::new + ), + // Data Tiers + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.DATA_TIERS, DataTiersFeatureSetUsage::new), + // Archive + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.ARCHIVE, ArchiveFeatureSetUsage::new), + // TSDB Downsampling + new NamedWriteableRegistry.Entry(LifecycleAction.class, DownsampleAction.NAME, DownsampleAction::new), + // Health API usage + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.HEALTH_API, HealthApiFeatureSetUsage::new), + // Remote cluster usage + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.REMOTE_CLUSTERS, RemoteClusterFeatureSetUsage::new), + // Enterprise Search + new NamedWriteableRegistry.Entry( + XPackFeatureUsage.class, + XPackField.ENTERPRISE_SEARCH, + EnterpriseSearchFeatureSetUsage::new + ), + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.UNIVERSAL_PROFILING, ProfilingUsage::new), + new NamedWriteableRegistry.Entry( + PersistentTaskParams.class, + SecurityMigrationTaskParams.TASK_NAME, + SecurityMigrationTaskParams::new + ), + new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.LOGSDB, LogsDBFeatureSetUsage::new) ), - // Data Streams - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.DATA_STREAMS, DataStreamFeatureSetUsage::new), - new NamedWriteableRegistry.Entry( - XPackFeatureUsage.class, - XPackField.DATA_STREAM_LIFECYCLE, - DataStreamLifecycleFeatureSetUsage::new - ), - // Data Tiers - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.DATA_TIERS, DataTiersFeatureSetUsage::new), - // Archive - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.ARCHIVE, ArchiveFeatureSetUsage::new), - // TSDB Downsampling - new NamedWriteableRegistry.Entry(LifecycleAction.class, DownsampleAction.NAME, DownsampleAction::new), - // Health API usage - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.HEALTH_API, HealthApiFeatureSetUsage::new), - // Remote cluster usage - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.REMOTE_CLUSTERS, RemoteClusterFeatureSetUsage::new), - // Enterprise Search - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.ENTERPRISE_SEARCH, EnterpriseSearchFeatureSetUsage::new), - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.UNIVERSAL_PROFILING, ProfilingUsage::new), + getChunkingSettingsNamedWriteables().stream() + ).filter(Objects::nonNull).toList(); + } + + /** + * @return List of chunking settings named writeable entries + */ + public static List getChunkingSettingsNamedWriteables() { + return List.of( + new NamedWriteableRegistry.Entry(ChunkingSettings.class, NoneChunkingSettings.NAME, in -> NoneChunkingSettings.INSTANCE), + new NamedWriteableRegistry.Entry(ChunkingSettings.class, WordBoundaryChunkingSettings.NAME, WordBoundaryChunkingSettings::new), new NamedWriteableRegistry.Entry( - PersistentTaskParams.class, - SecurityMigrationTaskParams.TASK_NAME, - SecurityMigrationTaskParams::new + ChunkingSettings.class, + SentenceBoundaryChunkingSettings.NAME, + SentenceBoundaryChunkingSettings::new ), - new NamedWriteableRegistry.Entry(XPackFeatureUsage.class, XPackField.LOGSDB, LogsDBFeatureSetUsage::new) - ).filter(Objects::nonNull).toList(); + new NamedWriteableRegistry.Entry(ChunkingSettings.class, RecursiveChunkingSettings.NAME, RecursiveChunkingSettings::new) + ); } @Override diff --git a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/InferenceUtils.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/InferenceUtils.java new file mode 100644 index 0000000000000..69baa702080d3 --- /dev/null +++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/InferenceUtils.java @@ -0,0 +1,256 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +package org.elasticsearch.xpack.core.inference; + +import org.elasticsearch.common.ValidationException; +import org.elasticsearch.core.Strings; + +import java.util.Arrays; +import java.util.EnumSet; +import java.util.List; +import java.util.Locale; +import java.util.Map; + +import static org.elasticsearch.core.Strings.format; + +public class InferenceUtils { + + private InferenceUtils() {} + + /** + * Remove the object from the map and cast to the expected type. + * If the object cannot be cast to type and error is added to the + * {@code validationException} parameter + * + * @param sourceMap Map containing fields + * @param key The key of the object to remove + * @param type The expected type of the removed object + * @param validationException If the value is not of type {@code type} + * @return {@code null} if not present else the object cast to type T + * @param The expected type + */ + @SuppressWarnings("unchecked") + public static T removeAsType(Map sourceMap, String key, Class type, ValidationException validationException) { + if (sourceMap == null) { + validationException.addValidationError(Strings.format("Encountered a null input map while parsing field [%s]", key)); + return null; + } + + Object o = sourceMap.remove(key); + if (o == null) { + return null; + } + + if (type.isAssignableFrom(o.getClass())) { + return (T) o; + } else { + validationException.addValidationError(invalidTypeErrorMsg(key, o, type.getSimpleName())); + return null; + } + } + + public static String extractOptionalString( + Map map, + String settingName, + String scope, + ValidationException validationException + ) { + int initialValidationErrorCount = validationException.validationErrors().size(); + String optionalField = removeAsType(map, settingName, String.class, validationException); + + if (validationException.validationErrors().size() > initialValidationErrorCount) { + // new validation error occurred + return null; + } + + if (optionalField != null && optionalField.isEmpty()) { + validationException.addValidationError(mustBeNonEmptyString(settingName, scope)); + } + + if (validationException.validationErrors().size() > initialValidationErrorCount) { + return null; + } + + return optionalField; + } + + public static Integer extractRequiredPositiveInteger( + Map map, + String settingName, + String scope, + ValidationException validationException + ) { + int initialValidationErrorCount = validationException.validationErrors().size(); + Integer field = InferenceUtils.removeAsType(map, settingName, Integer.class, validationException); + + if (validationException.validationErrors().size() > initialValidationErrorCount) { + return null; + } + + if (field == null) { + validationException.addValidationError(InferenceUtils.missingSettingErrorMsg(settingName, scope)); + } else if (field <= 0) { + validationException.addValidationError(InferenceUtils.mustBeAPositiveIntegerErrorMessage(settingName, scope, field)); + } + + if (validationException.validationErrors().size() > initialValidationErrorCount) { + return null; + } + + return field; + } + + public static Integer extractRequiredPositiveIntegerGreaterThanOrEqualToMin( + Map map, + String settingName, + int minValue, + String scope, + ValidationException validationException + ) { + Integer field = extractRequiredPositiveInteger(map, settingName, scope, validationException); + + if (field != null && field < minValue) { + validationException.addValidationError( + InferenceUtils.mustBeGreaterThanOrEqualNumberErrorMessage(settingName, scope, field, minValue) + ); + return null; + } + + return field; + } + + public static Integer extractRequiredPositiveIntegerLessThanOrEqualToMax( + Map map, + String settingName, + int maxValue, + String scope, + ValidationException validationException + ) { + Integer field = extractRequiredPositiveInteger(map, settingName, scope, validationException); + + if (field != null && field > maxValue) { + validationException.addValidationError( + InferenceUtils.mustBeLessThanOrEqualNumberErrorMessage(settingName, scope, field, maxValue) + ); + } + + return field; + } + + @SuppressWarnings("unchecked") + public static List extractOptionalList( + Map map, + String settingName, + Class type, + ValidationException validationException + ) { + int initialValidationErrorCount = validationException.validationErrors().size(); + var optionalField = InferenceUtils.removeAsType(map, settingName, List.class, validationException); + + if (validationException.validationErrors().size() > initialValidationErrorCount) { + return null; + } + + if (optionalField != null) { + for (Object o : optionalField) { + if (o.getClass().equals(type) == false) { + validationException.addValidationError(InferenceUtils.invalidTypeErrorMsg(settingName, o, "String")); + } + } + } + + if (validationException.validationErrors().size() > initialValidationErrorCount) { + return null; + } + + return (List) optionalField; + } + + public static > E extractOptionalEnum( + Map map, + String settingName, + String scope, + EnumConstructor constructor, + EnumSet validValues, + ValidationException validationException + ) { + var enumString = extractOptionalString(map, settingName, scope, validationException); + if (enumString == null) { + return null; + } + + try { + var createdEnum = constructor.apply(enumString); + validateEnumValue(createdEnum, validValues); + + return createdEnum; + } catch (IllegalArgumentException e) { + var validValuesAsStrings = validValues.stream().map(value -> value.toString().toLowerCase(Locale.ROOT)).toArray(String[]::new); + validationException.addValidationError(invalidValue(settingName, scope, enumString, validValuesAsStrings)); + } + + return null; + } + + private static > void validateEnumValue(E enumValue, EnumSet validValues) { + if (validValues.contains(enumValue) == false) { + throw new IllegalArgumentException(Strings.format("Enum value [%s] is not one of the acceptable values", enumValue.toString())); + } + } + + public static String mustBeNonEmptyString(String settingName, String scope) { + return Strings.format("[%s] Invalid value empty string. [%s] must be a non-empty string", scope, settingName); + } + + public static String invalidValue(String settingName, String scope, String invalidType, String[] requiredValues) { + var copyOfRequiredValues = requiredValues.clone(); + Arrays.sort(copyOfRequiredValues); + + return Strings.format( + "[%s] Invalid value [%s] received. [%s] must be one of [%s]", + scope, + invalidType, + settingName, + String.join(", ", copyOfRequiredValues) + ); + } + + public static String invalidTypeErrorMsg(String settingName, Object foundObject, String expectedType) { + return Strings.format( + "field [%s] is not of the expected type. The value [%s] cannot be converted to a [%s]", + settingName, + foundObject, + expectedType + ); + } + + public static String missingSettingErrorMsg(String settingName, String scope) { + return Strings.format("[%s] does not contain the required setting [%s]", scope, settingName); + } + + public static String mustBeGreaterThanOrEqualNumberErrorMessage(String settingName, String scope, double value, double minValue) { + return format("[%s] Invalid value [%s]. [%s] must be a greater than or equal to [%s]", scope, value, settingName, minValue); + } + + public static String mustBeLessThanOrEqualNumberErrorMessage(String settingName, String scope, double value, double maxValue) { + return format("[%s] Invalid value [%s]. [%s] must be a less than or equal to [%s]", scope, value, settingName, maxValue); + } + + public static String mustBeAPositiveIntegerErrorMessage(String settingName, String scope, int value) { + return format("[%s] Invalid value [%s]. [%s] must be a positive integer", scope, value, settingName); + } + + /** + * Functional interface for creating an enum from a string. + * @param + */ + @FunctionalInterface + public interface EnumConstructor> { + E apply(String name) throws IllegalArgumentException; + } +} diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/ChunkingSettingsBuilder.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/ChunkingSettingsBuilder.java similarity index 98% rename from x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/ChunkingSettingsBuilder.java rename to x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/ChunkingSettingsBuilder.java index 12c41c7ea9470..91016de86a55d 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/ChunkingSettingsBuilder.java +++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/ChunkingSettingsBuilder.java @@ -5,7 +5,7 @@ * 2.0. */ -package org.elasticsearch.xpack.inference.chunking; +package org.elasticsearch.xpack.core.inference.chunking; import org.elasticsearch.inference.ChunkingSettings; import org.elasticsearch.inference.ChunkingStrategy; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/ChunkingSettingsOptions.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/ChunkingSettingsOptions.java similarity index 93% rename from x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/ChunkingSettingsOptions.java rename to x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/ChunkingSettingsOptions.java index c5e4abd3648c5..b71fa96676523 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/ChunkingSettingsOptions.java +++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/ChunkingSettingsOptions.java @@ -5,7 +5,7 @@ * 2.0. */ -package org.elasticsearch.xpack.inference.chunking; +package org.elasticsearch.xpack.core.inference.chunking; public enum ChunkingSettingsOptions { STRATEGY("strategy"), diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/NoneChunkingSettings.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/NoneChunkingSettings.java similarity index 98% rename from x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/NoneChunkingSettings.java rename to x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/NoneChunkingSettings.java index e80d410be61ae..efc63388167a2 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/NoneChunkingSettings.java +++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/NoneChunkingSettings.java @@ -5,7 +5,7 @@ * 2.0. */ -package org.elasticsearch.xpack.inference.chunking; +package org.elasticsearch.xpack.core.inference.chunking; import org.elasticsearch.TransportVersion; import org.elasticsearch.common.Strings; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/RecursiveChunkingSettings.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/RecursiveChunkingSettings.java similarity index 94% rename from x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/RecursiveChunkingSettings.java rename to x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/RecursiveChunkingSettings.java index be6bdb6b16b1c..1e360ab43d60f 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/RecursiveChunkingSettings.java +++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/RecursiveChunkingSettings.java @@ -5,7 +5,7 @@ * 2.0. */ -package org.elasticsearch.xpack.inference.chunking; +package org.elasticsearch.xpack.core.inference.chunking; import org.elasticsearch.TransportVersion; import org.elasticsearch.common.Strings; @@ -16,7 +16,7 @@ import org.elasticsearch.inference.ChunkingStrategy; import org.elasticsearch.inference.ModelConfigurations; import org.elasticsearch.xcontent.XContentBuilder; -import org.elasticsearch.xpack.inference.services.ServiceUtils; +import org.elasticsearch.xpack.core.inference.InferenceUtils; import java.io.IOException; import java.util.Arrays; @@ -81,7 +81,7 @@ public static RecursiveChunkingSettings fromMap(Map map) { ); } - Integer maxChunkSize = ServiceUtils.extractRequiredPositiveIntegerGreaterThanOrEqualToMin( + Integer maxChunkSize = InferenceUtils.extractRequiredPositiveIntegerGreaterThanOrEqualToMin( map, ChunkingSettingsOptions.MAX_CHUNK_SIZE.toString(), MAX_CHUNK_SIZE_LOWER_LIMIT, @@ -89,7 +89,7 @@ public static RecursiveChunkingSettings fromMap(Map map) { validationException ); - SeparatorGroup separatorGroup = ServiceUtils.extractOptionalEnum( + SeparatorGroup separatorGroup = InferenceUtils.extractOptionalEnum( map, ChunkingSettingsOptions.SEPARATOR_GROUP.toString(), ModelConfigurations.CHUNKING_SETTINGS, @@ -98,7 +98,7 @@ public static RecursiveChunkingSettings fromMap(Map map) { validationException ); - List separators = ServiceUtils.extractOptionalList( + List separators = InferenceUtils.extractOptionalList( map, ChunkingSettingsOptions.SEPARATORS.toString(), String.class, diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/SentenceBoundaryChunkingSettings.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/SentenceBoundaryChunkingSettings.java similarity index 94% rename from x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/SentenceBoundaryChunkingSettings.java rename to x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/SentenceBoundaryChunkingSettings.java index 0700e47bef03d..7bf970ebcc8af 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/SentenceBoundaryChunkingSettings.java +++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/SentenceBoundaryChunkingSettings.java @@ -5,7 +5,7 @@ * 2.0. */ -package org.elasticsearch.xpack.inference.chunking; +package org.elasticsearch.xpack.core.inference.chunking; import org.elasticsearch.TransportVersion; import org.elasticsearch.TransportVersions; @@ -18,7 +18,7 @@ import org.elasticsearch.inference.ChunkingStrategy; import org.elasticsearch.inference.ModelConfigurations; import org.elasticsearch.xcontent.XContentBuilder; -import org.elasticsearch.xpack.inference.services.ServiceUtils; +import org.elasticsearch.xpack.core.inference.InferenceUtils; import java.io.IOException; import java.util.Arrays; @@ -57,6 +57,10 @@ public Integer maxChunkSize() { return maxChunkSize; } + public int sentenceOverlap() { + return sentenceOverlap; + } + @Override public void validate() { ValidationException validationException = new ValidationException(); @@ -100,7 +104,7 @@ public static SentenceBoundaryChunkingSettings fromMap(Map map) ); } - Integer maxChunkSize = ServiceUtils.extractRequiredPositiveIntegerGreaterThanOrEqualToMin( + Integer maxChunkSize = InferenceUtils.extractRequiredPositiveIntegerGreaterThanOrEqualToMin( map, ChunkingSettingsOptions.MAX_CHUNK_SIZE.toString(), MAX_CHUNK_SIZE_LOWER_LIMIT, @@ -108,7 +112,7 @@ public static SentenceBoundaryChunkingSettings fromMap(Map map) validationException ); - Integer sentenceOverlap = ServiceUtils.removeAsType( + Integer sentenceOverlap = InferenceUtils.removeAsType( map, ChunkingSettingsOptions.SENTENCE_OVERLAP.toString(), Integer.class, diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/SeparatorGroup.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/SeparatorGroup.java similarity index 95% rename from x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/SeparatorGroup.java rename to x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/SeparatorGroup.java index cafd3b08ccf9b..9c451b34ea8d2 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/SeparatorGroup.java +++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/SeparatorGroup.java @@ -5,7 +5,7 @@ * 2.0. */ -package org.elasticsearch.xpack.inference.chunking; +package org.elasticsearch.xpack.core.inference.chunking; import java.util.List; import java.util.Locale; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/WordBoundaryChunkingSettings.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/WordBoundaryChunkingSettings.java similarity index 94% rename from x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/WordBoundaryChunkingSettings.java rename to x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/WordBoundaryChunkingSettings.java index 055df300bfd3e..60889988ed7e9 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/WordBoundaryChunkingSettings.java +++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/inference/chunking/WordBoundaryChunkingSettings.java @@ -5,7 +5,7 @@ * 2.0. */ -package org.elasticsearch.xpack.inference.chunking; +package org.elasticsearch.xpack.core.inference.chunking; import org.elasticsearch.TransportVersion; import org.elasticsearch.TransportVersions; @@ -17,7 +17,7 @@ import org.elasticsearch.inference.ChunkingStrategy; import org.elasticsearch.inference.ModelConfigurations; import org.elasticsearch.xcontent.XContentBuilder; -import org.elasticsearch.xpack.inference.services.ServiceUtils; +import org.elasticsearch.xpack.core.inference.InferenceUtils; import java.io.IOException; import java.util.Arrays; @@ -100,7 +100,7 @@ public static WordBoundaryChunkingSettings fromMap(Map map) { ); } - Integer maxChunkSize = ServiceUtils.extractRequiredPositiveIntegerGreaterThanOrEqualToMin( + Integer maxChunkSize = InferenceUtils.extractRequiredPositiveIntegerGreaterThanOrEqualToMin( map, ChunkingSettingsOptions.MAX_CHUNK_SIZE.toString(), MAX_CHUNK_SIZE_LOWER_LIMIT, @@ -110,7 +110,7 @@ public static WordBoundaryChunkingSettings fromMap(Map map) { Integer overlap = null; if (maxChunkSize != null) { - overlap = ServiceUtils.extractRequiredPositiveIntegerLessThanOrEqualToMax( + overlap = InferenceUtils.extractRequiredPositiveIntegerLessThanOrEqualToMax( map, ChunkingSettingsOptions.OVERLAP.toString(), maxChunkSize / 2, diff --git a/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/inference/InferenceUtilsTests.java b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/inference/InferenceUtilsTests.java new file mode 100644 index 0000000000000..0bced6ea7b004 --- /dev/null +++ b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/inference/InferenceUtilsTests.java @@ -0,0 +1,421 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0; you may not use this file except in compliance with the Elastic License + * 2.0. + */ + +package org.elasticsearch.xpack.core.inference; + +import org.elasticsearch.common.ValidationException; +import org.elasticsearch.inference.InputType; +import org.elasticsearch.test.ESTestCase; + +import java.util.EnumSet; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.elasticsearch.xpack.core.inference.InferenceUtils.extractOptionalEnum; +import static org.elasticsearch.xpack.core.inference.InferenceUtils.extractOptionalList; +import static org.elasticsearch.xpack.core.inference.InferenceUtils.extractOptionalString; +import static org.elasticsearch.xpack.core.inference.InferenceUtils.extractRequiredPositiveInteger; +import static org.elasticsearch.xpack.core.inference.InferenceUtils.extractRequiredPositiveIntegerGreaterThanOrEqualToMin; +import static org.elasticsearch.xpack.core.inference.InferenceUtils.extractRequiredPositiveIntegerLessThanOrEqualToMax; +import static org.hamcrest.Matchers.containsString; +import static org.hamcrest.Matchers.empty; +import static org.hamcrest.Matchers.hasSize; +import static org.hamcrest.Matchers.is; + +public class InferenceUtilsTests extends ESTestCase { + + public void testRemoveAsType_Validation_WithTheCorrectType() { + Map map = new HashMap<>(Map.of("a", 5, "b", "a string", "c", Boolean.TRUE, "d", 1.0)); + + ValidationException validationException = new ValidationException(); + Integer i = InferenceUtils.removeAsType(map, "a", Integer.class, validationException); + assertEquals(Integer.valueOf(5), i); + assertNull(map.get("a")); // field has been removed + assertThat(validationException.validationErrors(), empty()); + + String str = InferenceUtils.removeAsType(map, "b", String.class, validationException); + assertEquals("a string", str); + assertNull(map.get("b")); + assertThat(validationException.validationErrors(), empty()); + } + + public void testRemoveAsType_Validation_WithInCorrectType() { + Map map = new HashMap<>(Map.of("a", 5, "b", "a string", "c", Boolean.TRUE, "d", 5.0, "e", 5)); + + var validationException = new ValidationException(); + Object result = InferenceUtils.removeAsType(map, "a", String.class, validationException); + assertNull(result); + assertThat(validationException.validationErrors(), hasSize(1)); + assertThat( + validationException.validationErrors().get(0), + containsString("field [a] is not of the expected type. The value [5] cannot be converted to a [String]") + ); + assertNull(map.get("a")); + + validationException = new ValidationException(); + InferenceUtils.removeAsType(map, "b", Boolean.class, validationException); + assertThat(validationException.validationErrors(), hasSize(1)); + assertThat( + validationException.validationErrors().get(0), + containsString("field [b] is not of the expected type. The value [a string] cannot be converted to a [Boolean]") + ); + assertNull(map.get("b")); + + validationException = new ValidationException(); + result = InferenceUtils.removeAsType(map, "c", Integer.class, validationException); + assertNull(result); + assertThat(validationException.validationErrors(), hasSize(1)); + assertThat( + validationException.validationErrors().get(0), + containsString("field [c] is not of the expected type. The value [true] cannot be converted to a [Integer]") + ); + assertNull(map.get("c")); + + // cannot convert double to integer + validationException = new ValidationException(); + result = InferenceUtils.removeAsType(map, "d", Integer.class, validationException); + assertNull(result); + assertThat(validationException.validationErrors(), hasSize(1)); + assertThat( + validationException.validationErrors().get(0), + containsString("field [d] is not of the expected type. The value [5.0] cannot be converted to a [Integer]") + ); + assertNull(map.get("d")); + + // cannot convert integer to double + validationException = new ValidationException(); + result = InferenceUtils.removeAsType(map, "e", Double.class, validationException); + assertNull(result); + assertThat(validationException.validationErrors(), hasSize(1)); + assertThat( + validationException.validationErrors().get(0), + containsString("field [e] is not of the expected type. The value [5] cannot be converted to a [Double]") + ); + assertNull(map.get("e")); + + assertThat(map.entrySet(), empty()); + } + + public void testExtractOptionalString_CreatesString() { + var validation = new ValidationException(); + Map map = modifiableMap(Map.of("key", "value")); + var createdString = extractOptionalString(map, "key", "scope", validation); + + assertTrue(validation.validationErrors().isEmpty()); + assertNotNull(createdString); + assertThat(createdString, is("value")); + assertTrue(map.isEmpty()); + } + + public void testExtractOptionalString_DoesNotAddException_WhenFieldDoesNotExist() { + var validation = new ValidationException(); + validation.addValidationError("previous error"); + Map map = modifiableMap(Map.of("key", "value")); + var createdString = extractOptionalString(map, "abc", "scope", validation); + + assertNull(createdString); + assertThat(validation.validationErrors(), hasSize(1)); + assertThat(map.size(), is(1)); + } + + public void testExtractOptionalString_AddsException_WhenFieldIsEmpty() { + var validation = new ValidationException(); + Map map = modifiableMap(Map.of("key", "")); + var createdString = extractOptionalString(map, "key", "scope", validation); + + assertNull(createdString); + assertFalse(validation.validationErrors().isEmpty()); + assertTrue(map.isEmpty()); + assertThat(validation.validationErrors().get(0), is("[scope] Invalid value empty string. [key] must be a non-empty string")); + } + + public void testExtractRequiredPositiveInteger_ReturnsValue() { + var validation = new ValidationException(); + validation.addValidationError("previous error"); + Map map = modifiableMap(Map.of("key", 1)); + var parsedInt = extractRequiredPositiveInteger(map, "key", "scope", validation); + + assertThat(validation.validationErrors(), hasSize(1)); + assertNotNull(parsedInt); + assertThat(parsedInt, is(1)); + assertTrue(map.isEmpty()); + } + + public void testExtractRequiredPositiveInteger_AddsErrorForNegativeValue() { + var validation = new ValidationException(); + validation.addValidationError("previous error"); + Map map = modifiableMap(Map.of("key", -1)); + var parsedInt = extractRequiredPositiveInteger(map, "key", "scope", validation); + + assertThat(validation.validationErrors(), hasSize(2)); + assertNull(parsedInt); + assertTrue(map.isEmpty()); + assertThat(validation.validationErrors().get(1), is("[scope] Invalid value [-1]. [key] must be a positive integer")); + } + + public void testExtractRequiredPositiveInteger_AddsErrorWhenKeyIsMissing() { + var validation = new ValidationException(); + validation.addValidationError("previous error"); + Map map = modifiableMap(Map.of("key", -1)); + var parsedInt = extractRequiredPositiveInteger(map, "not_key", "scope", validation); + + assertThat(validation.validationErrors(), hasSize(2)); + assertNull(parsedInt); + assertThat(validation.validationErrors().get(1), is("[scope] does not contain the required setting [not_key]")); + } + + public void testExtractRequiredPositiveIntegerLessThanOrEqualToMax_ReturnsValueWhenValueIsLessThanMax() { + var validation = new ValidationException(); + validation.addValidationError("previous error"); + Map map = modifiableMap(Map.of("key", 1)); + var parsedInt = extractRequiredPositiveIntegerLessThanOrEqualToMax(map, "key", 5, "scope", validation); + + assertThat(validation.validationErrors(), hasSize(1)); + assertNotNull(parsedInt); + assertThat(parsedInt, is(1)); + assertTrue(map.isEmpty()); + } + + public void testExtractRequiredPositiveIntegerLessThanOrEqualToMax_ReturnsValueWhenValueIsEqualToMax() { + var validation = new ValidationException(); + validation.addValidationError("previous error"); + Map map = modifiableMap(Map.of("key", 5)); + var parsedInt = extractRequiredPositiveIntegerLessThanOrEqualToMax(map, "key", 5, "scope", validation); + + assertThat(validation.validationErrors(), hasSize(1)); + assertNotNull(parsedInt); + assertThat(parsedInt, is(5)); + assertTrue(map.isEmpty()); + } + + public void testExtractRequiredPositiveIntegerLessThanOrEqualToMax_AddsErrorForNegativeValue() { + var validation = new ValidationException(); + validation.addValidationError("previous error"); + Map map = modifiableMap(Map.of("key", -1)); + var parsedInt = extractRequiredPositiveIntegerLessThanOrEqualToMax(map, "key", 5, "scope", validation); + + assertThat(validation.validationErrors(), hasSize(2)); + assertNull(parsedInt); + assertTrue(map.isEmpty()); + assertThat(validation.validationErrors().get(1), is("[scope] Invalid value [-1]. [key] must be a positive integer")); + } + + public void testExtractRequiredPositiveIntegerLessThanOrEqualToMax_AddsErrorWhenKeyIsMissing() { + var validation = new ValidationException(); + validation.addValidationError("previous error"); + Map map = modifiableMap(Map.of("key", -1)); + var parsedInt = extractRequiredPositiveIntegerLessThanOrEqualToMax(map, "not_key", 5, "scope", validation); + + assertThat(validation.validationErrors(), hasSize(2)); + assertNull(parsedInt); + assertThat(validation.validationErrors().get(1), is("[scope] does not contain the required setting [not_key]")); + } + + public void testExtractRequiredPositiveIntegerLessThanOrEqualToMax_AddsErrorWhenValueIsGreaterThanMax() { + var validation = new ValidationException(); + validation.addValidationError("previous error"); + Map map = modifiableMap(Map.of("key", 6)); + var parsedInt = extractRequiredPositiveIntegerLessThanOrEqualToMax(map, "not_key", 5, "scope", validation); + + assertThat(validation.validationErrors(), hasSize(2)); + assertNull(parsedInt); + assertThat(validation.validationErrors().get(1), is("[scope] does not contain the required setting [not_key]")); + } + + public void testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_ReturnsValueWhenValueIsEqualToMin() { + testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_Successful(5, 5); + } + + public void testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_ReturnsValueWhenValueIsGreaterThanToMin() { + testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_Successful(5, 6); + } + + private void testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_Successful(int minValue, int actualValue) { + var validation = new ValidationException(); + validation.addValidationError("previous error"); + Map map = modifiableMap(Map.of("key", actualValue)); + var parsedInt = extractRequiredPositiveIntegerGreaterThanOrEqualToMin(map, "key", minValue, "scope", validation); + + assertThat(validation.validationErrors(), hasSize(1)); + assertNotNull(parsedInt); + assertThat(parsedInt, is(actualValue)); + assertTrue(map.isEmpty()); + } + + public void testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_AddsErrorWhenValueIsLessThanMin() { + testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_AddsError( + "key", + 5, + 4, + "[scope] Invalid value [4.0]. [key] must be a greater than or equal to [5.0]" + ); + } + + public void testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_AddsErrorWhenKeyIsMissing() { + testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_AddsError( + "not_key", + 5, + -1, + "[scope] does not contain the required setting [not_key]" + ); + } + + public void testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_AddsErrorOnNegativeValue() { + testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_AddsError( + "key", + 5, + -1, + "[scope] Invalid value [-1]. [key] must be a positive integer" + ); + } + + private void testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_AddsError( + String key, + int minValue, + int actualValue, + String error + ) { + var validation = new ValidationException(); + validation.addValidationError("previous error"); + Map map = modifiableMap(Map.of("key", actualValue)); + var parsedInt = extractRequiredPositiveIntegerGreaterThanOrEqualToMin(map, key, minValue, "scope", validation); + + assertThat(validation.validationErrors(), hasSize(2)); + assertNull(parsedInt); + assertThat(validation.validationErrors().get(1), containsString(error)); + } + + public void testExtractOptionalList_CreatesList() { + var validation = new ValidationException(); + var list = List.of(randomAlphaOfLength(10), randomAlphaOfLength(10)); + + Map map = modifiableMap(Map.of("key", list)); + assertEquals(list, extractOptionalList(map, "key", String.class, validation)); + assertTrue(validation.validationErrors().isEmpty()); + assertTrue(map.isEmpty()); + } + + public void testExtractOptionalList_AddsException_WhenFieldDoesNotExist() { + var validation = new ValidationException(); + validation.addValidationError("previous error"); + Map map = modifiableMap(Map.of("key", List.of(randomAlphaOfLength(10), randomAlphaOfLength(10)))); + assertNull(extractOptionalList(map, "abc", String.class, validation)); + assertThat(validation.validationErrors(), hasSize(1)); + assertThat(map.size(), is(1)); + } + + public void testExtractOptionalList_AddsException_WhenFieldIsEmpty() { + var validation = new ValidationException(); + validation.addValidationError("previous error"); + Map map = modifiableMap(Map.of("key", "")); + assertNull(extractOptionalList(map, "key", String.class, validation)); + assertFalse(validation.validationErrors().isEmpty()); + assertTrue(map.isEmpty()); + } + + public void testExtractOptionalList_AddsException_WhenFieldIsNotAList() { + var validation = new ValidationException(); + validation.addValidationError("previous error"); + Map map = modifiableMap(Map.of("key", 1)); + assertNull(extractOptionalList(map, "key", String.class, validation)); + assertFalse(validation.validationErrors().isEmpty()); + assertTrue(map.isEmpty()); + } + + public void testExtractOptionalList_AddsException_WhenFieldIsNotAListOfTheCorrectType() { + var validation = new ValidationException(); + validation.addValidationError("previous error"); + Map map = modifiableMap(Map.of("key", List.of(1, 2))); + assertNull(extractOptionalList(map, "key", String.class, validation)); + assertFalse(validation.validationErrors().isEmpty()); + assertTrue(map.isEmpty()); + } + + public void testExtractOptionalList_AddsException_WhenFieldContainsMixedTypeValues() { + var validation = new ValidationException(); + validation.addValidationError("previous error"); + Map map = modifiableMap(Map.of("key", List.of(1, "a"))); + assertNull(extractOptionalList(map, "key", String.class, validation)); + assertFalse(validation.validationErrors().isEmpty()); + assertTrue(map.isEmpty()); + } + + public void testExtractOptionalEnum_ReturnsNull_WhenFieldDoesNotExist() { + var validation = new ValidationException(); + Map map = modifiableMap(Map.of("key", "value")); + var createdEnum = extractOptionalEnum(map, "abc", "scope", InputType::fromString, EnumSet.allOf(InputType.class), validation); + + assertNull(createdEnum); + assertTrue(validation.validationErrors().isEmpty()); + assertThat(map.size(), is(1)); + } + + public void testExtractOptionalEnum_ReturnsNullAndAddsException_WhenAnInvalidValueExists() { + var validation = new ValidationException(); + Map map = modifiableMap(Map.of("key", "invalid_value")); + var createdEnum = extractOptionalEnum( + map, + "key", + "scope", + InputType::fromString, + EnumSet.of(InputType.INGEST, InputType.SEARCH), + validation + ); + + assertNull(createdEnum); + assertFalse(validation.validationErrors().isEmpty()); + assertTrue(map.isEmpty()); + assertThat( + validation.validationErrors().get(0), + is("[scope] Invalid value [invalid_value] received. [key] must be one of [ingest, search]") + ); + } + + public void testExtractOptionalEnum_ReturnsNullAndAddsException_WhenValueIsNotPartOfTheAcceptableValues() { + var validation = new ValidationException(); + Map map = modifiableMap(Map.of("key", InputType.UNSPECIFIED.toString())); + var createdEnum = extractOptionalEnum(map, "key", "scope", InputType::fromString, EnumSet.of(InputType.INGEST), validation); + + assertNull(createdEnum); + assertFalse(validation.validationErrors().isEmpty()); + assertTrue(map.isEmpty()); + assertThat(validation.validationErrors().get(0), is("[scope] Invalid value [unspecified] received. [key] must be one of [ingest]")); + } + + public void testExtractOptionalEnum_ReturnsIngest_WhenValueIsAcceptable() { + var validation = new ValidationException(); + Map map = modifiableMap(Map.of("key", InputType.INGEST.toString())); + var createdEnum = extractOptionalEnum(map, "key", "scope", InputType::fromString, EnumSet.of(InputType.INGEST), validation); + + assertThat(createdEnum, is(InputType.INGEST)); + assertTrue(validation.validationErrors().isEmpty()); + assertTrue(map.isEmpty()); + } + + public void testExtractOptionalEnum_ReturnsClassification_WhenValueIsAcceptable() { + var validation = new ValidationException(); + Map map = modifiableMap(Map.of("key", InputType.CLASSIFICATION.toString())); + var createdEnum = extractOptionalEnum( + map, + "key", + "scope", + InputType::fromString, + EnumSet.of(InputType.INGEST, InputType.CLASSIFICATION), + validation + ); + + assertThat(createdEnum, is(InputType.CLASSIFICATION)); + assertTrue(validation.validationErrors().isEmpty()); + assertTrue(map.isEmpty()); + } + + public static Map modifiableMap(Map aMap) { + return new HashMap<>(aMap); + } + +} diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/ChunkingSettingsTests.java b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/inference/chunking/ChunkingSettingsTests.java similarity index 97% rename from x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/ChunkingSettingsTests.java rename to x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/inference/chunking/ChunkingSettingsTests.java index 4311b68ec18d3..c61830a4e8608 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/ChunkingSettingsTests.java +++ b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/inference/chunking/ChunkingSettingsTests.java @@ -5,7 +5,7 @@ * 2.0. */ -package org.elasticsearch.xpack.inference.chunking; +package org.elasticsearch.xpack.core.inference.chunking; import org.elasticsearch.inference.ChunkingSettings; import org.elasticsearch.inference.ChunkingStrategy; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/NoneChunkingSettingsTests.java b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/inference/chunking/NoneChunkingSettingsTests.java similarity index 94% rename from x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/NoneChunkingSettingsTests.java rename to x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/inference/chunking/NoneChunkingSettingsTests.java index 660b223d0cab0..0509a89df699d 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/NoneChunkingSettingsTests.java +++ b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/inference/chunking/NoneChunkingSettingsTests.java @@ -5,7 +5,7 @@ * 2.0. */ -package org.elasticsearch.xpack.inference.chunking; +package org.elasticsearch.xpack.core.inference.chunking; import org.elasticsearch.common.io.stream.Writeable; import org.elasticsearch.test.AbstractWireSerializingTestCase; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/RecursiveChunkingSettingsTests.java b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/inference/chunking/RecursiveChunkingSettingsTests.java similarity index 98% rename from x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/RecursiveChunkingSettingsTests.java rename to x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/inference/chunking/RecursiveChunkingSettingsTests.java index 77c651168a39d..7d981aa94cfdd 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/RecursiveChunkingSettingsTests.java +++ b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/inference/chunking/RecursiveChunkingSettingsTests.java @@ -5,7 +5,7 @@ * 2.0. */ -package org.elasticsearch.xpack.inference.chunking; +package org.elasticsearch.xpack.core.inference.chunking; import org.elasticsearch.common.ValidationException; import org.elasticsearch.common.io.stream.Writeable; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/SentenceBoundaryChunkingSettingsTests.java b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/inference/chunking/SentenceBoundaryChunkingSettingsTests.java similarity index 93% rename from x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/SentenceBoundaryChunkingSettingsTests.java rename to x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/inference/chunking/SentenceBoundaryChunkingSettingsTests.java index 47a1a116ba21e..20a5696dce949 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/SentenceBoundaryChunkingSettingsTests.java +++ b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/inference/chunking/SentenceBoundaryChunkingSettingsTests.java @@ -5,7 +5,7 @@ * 2.0. */ -package org.elasticsearch.xpack.inference.chunking; +package org.elasticsearch.xpack.core.inference.chunking; import org.elasticsearch.common.ValidationException; import org.elasticsearch.common.io.stream.Writeable; @@ -40,7 +40,7 @@ public void testValidInputsProvided() { ); assertEquals(settings.getChunkingStrategy(), ChunkingStrategy.SENTENCE); - assertEquals(settings.maxChunkSize, maxChunkSize); + assertEquals((int) settings.maxChunkSize(), maxChunkSize); } public Map buildChunkingSettingsMap(Optional maxChunkSize) { @@ -63,7 +63,7 @@ protected SentenceBoundaryChunkingSettings createTestInstance() { @Override protected SentenceBoundaryChunkingSettings mutateInstance(SentenceBoundaryChunkingSettings instance) throws IOException { - var chunkSize = randomValueOtherThan(instance.maxChunkSize, () -> randomIntBetween(20, 300)); - return new SentenceBoundaryChunkingSettings(chunkSize, instance.sentenceOverlap); + var chunkSize = randomValueOtherThan(instance.maxChunkSize(), () -> randomIntBetween(20, 300)); + return new SentenceBoundaryChunkingSettings(chunkSize, instance.sentenceOverlap()); } } diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/WordBoundaryChunkingSettingsTests.java b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/inference/chunking/WordBoundaryChunkingSettingsTests.java similarity index 91% rename from x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/WordBoundaryChunkingSettingsTests.java rename to x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/inference/chunking/WordBoundaryChunkingSettingsTests.java index dd91a3c7a947e..d86c67b20cd7a 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/WordBoundaryChunkingSettingsTests.java +++ b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/inference/chunking/WordBoundaryChunkingSettingsTests.java @@ -5,7 +5,7 @@ * 2.0. */ -package org.elasticsearch.xpack.inference.chunking; +package org.elasticsearch.xpack.core.inference.chunking; import org.elasticsearch.common.ValidationException; import org.elasticsearch.common.io.stream.Writeable; @@ -55,8 +55,8 @@ public void testValidInputsProvided() { ); assertEquals(settings.getChunkingStrategy(), ChunkingStrategy.WORD); - assertEquals(settings.maxChunkSize, maxChunkSize); - assertEquals(settings.overlap, overlap); + assertEquals((int) settings.maxChunkSize(), maxChunkSize); + assertEquals(settings.overlap(), overlap); } public Map buildChunkingSettingsMap(Optional maxChunkSize, Optional overlap) { @@ -81,8 +81,8 @@ protected WordBoundaryChunkingSettings createTestInstance() { @Override protected WordBoundaryChunkingSettings mutateInstance(WordBoundaryChunkingSettings instance) throws IOException { - var maxChunkSize = randomValueOtherThan(instance.maxChunkSize, () -> randomIntBetween(10, 300)); - var overlap = randomValueOtherThan(instance.overlap, () -> randomIntBetween(1, maxChunkSize / 2)); + var maxChunkSize = randomValueOtherThan(instance.maxChunkSize(), () -> randomIntBetween(10, 300)); + var overlap = randomValueOtherThan(instance.overlap(), () -> randomIntBetween(1, maxChunkSize / 2)); return new WordBoundaryChunkingSettings(maxChunkSize, overlap); } diff --git a/x-pack/plugin/inference/qa/test-service-plugin/src/main/java/org/elasticsearch/xpack/inference/mock/AbstractTestInferenceService.java b/x-pack/plugin/inference/qa/test-service-plugin/src/main/java/org/elasticsearch/xpack/inference/mock/AbstractTestInferenceService.java index 44c9d0463cd05..a644cb529a3a1 100644 --- a/x-pack/plugin/inference/qa/test-service-plugin/src/main/java/org/elasticsearch/xpack/inference/mock/AbstractTestInferenceService.java +++ b/x-pack/plugin/inference/qa/test-service-plugin/src/main/java/org/elasticsearch/xpack/inference/mock/AbstractTestInferenceService.java @@ -25,9 +25,9 @@ import org.elasticsearch.inference.TaskSettings; import org.elasticsearch.inference.TaskType; import org.elasticsearch.xcontent.XContentBuilder; +import org.elasticsearch.xpack.core.inference.chunking.WordBoundaryChunkingSettings; import org.elasticsearch.xpack.inference.chunking.NoopChunker; import org.elasticsearch.xpack.inference.chunking.WordBoundaryChunker; -import org.elasticsearch.xpack.inference.chunking.WordBoundaryChunkingSettings; import java.io.IOException; import java.util.ArrayList; diff --git a/x-pack/plugin/inference/src/internalClusterTest/java/org/elasticsearch/xpack/inference/integration/ModelRegistryIT.java b/x-pack/plugin/inference/src/internalClusterTest/java/org/elasticsearch/xpack/inference/integration/ModelRegistryIT.java index 92eea9599ec5d..5448811b1c2ae 100644 --- a/x-pack/plugin/inference/src/internalClusterTest/java/org/elasticsearch/xpack/inference/integration/ModelRegistryIT.java +++ b/x-pack/plugin/inference/src/internalClusterTest/java/org/elasticsearch/xpack/inference/integration/ModelRegistryIT.java @@ -39,8 +39,8 @@ import org.elasticsearch.threadpool.ThreadPool; import org.elasticsearch.xcontent.ToXContentObject; import org.elasticsearch.xcontent.XContentBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests; import org.elasticsearch.xpack.inference.LocalStateInferencePlugin; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests; import org.elasticsearch.xpack.inference.model.TestModel; import org.elasticsearch.xpack.inference.registry.ModelRegistry; import org.elasticsearch.xpack.inference.registry.ModelRegistryTests; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/InferenceNamedWriteablesProvider.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/InferenceNamedWriteablesProvider.java index b1887cff763fa..951bb9e5802c9 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/InferenceNamedWriteablesProvider.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/InferenceNamedWriteablesProvider.java @@ -11,7 +11,6 @@ import org.elasticsearch.cluster.NamedDiff; import org.elasticsearch.cluster.metadata.Metadata; import org.elasticsearch.common.io.stream.NamedWriteableRegistry; -import org.elasticsearch.inference.ChunkingSettings; import org.elasticsearch.inference.EmptySecretSettings; import org.elasticsearch.inference.EmptyTaskSettings; import org.elasticsearch.inference.InferenceServiceResults; @@ -27,10 +26,6 @@ import org.elasticsearch.xpack.core.inference.results.TextEmbeddingByteResults; import org.elasticsearch.xpack.core.inference.results.TextEmbeddingFloatResults; import org.elasticsearch.xpack.inference.action.task.StreamingTaskManager; -import org.elasticsearch.xpack.inference.chunking.NoneChunkingSettings; -import org.elasticsearch.xpack.inference.chunking.RecursiveChunkingSettings; -import org.elasticsearch.xpack.inference.chunking.SentenceBoundaryChunkingSettings; -import org.elasticsearch.xpack.inference.chunking.WordBoundaryChunkingSettings; import org.elasticsearch.xpack.inference.common.amazon.AwsSecretSettings; import org.elasticsearch.xpack.inference.registry.ClearInferenceEndpointCacheAction; import org.elasticsearch.xpack.inference.services.ai21.completion.Ai21ChatCompletionServiceSettings; @@ -147,8 +142,6 @@ public static List getNamedWriteables() { // Empty default task settings namedWriteables.add(new NamedWriteableRegistry.Entry(TaskSettings.class, EmptyTaskSettings.NAME, EmptyTaskSettings::new)); - addChunkingSettingsNamedWriteables(namedWriteables); - // Empty default secret settings namedWriteables.add(new NamedWriteableRegistry.Entry(SecretSettings.class, EmptySecretSettings.NAME, EmptySecretSettings::new)); @@ -625,25 +618,6 @@ private static void addInternalNamedWriteables(List namedWriteables) { - namedWriteables.add( - new NamedWriteableRegistry.Entry(ChunkingSettings.class, NoneChunkingSettings.NAME, in -> NoneChunkingSettings.INSTANCE) - ); - namedWriteables.add( - new NamedWriteableRegistry.Entry(ChunkingSettings.class, WordBoundaryChunkingSettings.NAME, WordBoundaryChunkingSettings::new) - ); - namedWriteables.add( - new NamedWriteableRegistry.Entry( - ChunkingSettings.class, - SentenceBoundaryChunkingSettings.NAME, - SentenceBoundaryChunkingSettings::new - ) - ); - namedWriteables.add( - new NamedWriteableRegistry.Entry(ChunkingSettings.class, RecursiveChunkingSettings.NAME, RecursiveChunkingSettings::new) - ); - } - private static void addInferenceResultsNamedWriteables(List namedWriteables) { namedWriteables.add( new NamedWriteableRegistry.Entry(InferenceServiceResults.class, SparseEmbeddingResults.NAME, SparseEmbeddingResults::new) diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/action/filter/ShardBulkInferenceActionFilter.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/action/filter/ShardBulkInferenceActionFilter.java index aef7b9089992b..de16671a18403 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/action/filter/ShardBulkInferenceActionFilter.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/action/filter/ShardBulkInferenceActionFilter.java @@ -58,9 +58,9 @@ import org.elasticsearch.xcontent.XContentParserConfiguration; import org.elasticsearch.xcontent.XContentType; import org.elasticsearch.xpack.core.XPackField; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.core.inference.results.ChunkedInferenceError; import org.elasticsearch.xpack.inference.InferenceException; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.mapper.SemanticTextField; import org.elasticsearch.xpack.inference.mapper.SemanticTextFieldMapper; import org.elasticsearch.xpack.inference.mapper.SemanticTextUtils; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/EmbeddingRequestChunker.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/EmbeddingRequestChunker.java index da071442d6c1b..53334f3a82c57 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/EmbeddingRequestChunker.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/EmbeddingRequestChunker.java @@ -16,6 +16,7 @@ import org.elasticsearch.inference.ChunkingStrategy; import org.elasticsearch.inference.InferenceServiceResults; import org.elasticsearch.rest.RestStatus; +import org.elasticsearch.xpack.core.inference.chunking.WordBoundaryChunkingSettings; import org.elasticsearch.xpack.core.inference.results.ChunkedInferenceEmbedding; import org.elasticsearch.xpack.core.inference.results.ChunkedInferenceError; import org.elasticsearch.xpack.core.inference.results.EmbeddingResults; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/NoopChunker.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/NoopChunker.java index 4698275de7c59..b8c4082b10ae0 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/NoopChunker.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/NoopChunker.java @@ -9,6 +9,7 @@ import org.elasticsearch.common.Strings; import org.elasticsearch.inference.ChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.NoneChunkingSettings; import org.elasticsearch.xpack.inference.services.openai.embeddings.OpenAiEmbeddingsModel; import java.util.List; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/RecursiveChunker.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/RecursiveChunker.java index ab0d1318d7066..b3d5d6af9496b 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/RecursiveChunker.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/RecursiveChunker.java @@ -11,6 +11,8 @@ import org.elasticsearch.common.Strings; import org.elasticsearch.inference.ChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.RecursiveChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.SentenceBoundaryChunkingSettings; import java.util.ArrayList; import java.util.List; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/RerankRequestChunker.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/RerankRequestChunker.java index 2b31796e0c640..8ace9e1815df5 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/RerankRequestChunker.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/RerankRequestChunker.java @@ -12,6 +12,7 @@ import org.elasticsearch.action.ActionListener; import org.elasticsearch.inference.ChunkingSettings; import org.elasticsearch.inference.InferenceServiceResults; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.core.inference.results.RankedDocsResults; import java.util.ArrayList; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/SentenceBoundaryChunker.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/SentenceBoundaryChunker.java index aa76c40085464..879c371b0450c 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/SentenceBoundaryChunker.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/SentenceBoundaryChunker.java @@ -11,6 +11,7 @@ import org.elasticsearch.common.Strings; import org.elasticsearch.inference.ChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.SentenceBoundaryChunkingSettings; import java.util.ArrayList; import java.util.List; @@ -46,7 +47,7 @@ public SentenceBoundaryChunker() { @Override public List chunk(String input, ChunkingSettings chunkingSettings) { if (chunkingSettings instanceof SentenceBoundaryChunkingSettings sentenceBoundaryChunkingSettings) { - return chunk(input, sentenceBoundaryChunkingSettings.maxChunkSize, sentenceBoundaryChunkingSettings.sentenceOverlap > 0); + return chunk(input, sentenceBoundaryChunkingSettings.maxChunkSize(), sentenceBoundaryChunkingSettings.sentenceOverlap() > 0); } else { throw new IllegalArgumentException( Strings.format( diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/WordBoundaryChunker.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/WordBoundaryChunker.java index 1ce90a9e416e5..e49dcd1bbcd53 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/WordBoundaryChunker.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/chunking/WordBoundaryChunker.java @@ -11,6 +11,7 @@ import org.elasticsearch.common.Strings; import org.elasticsearch.inference.ChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.WordBoundaryChunkingSettings; import java.util.ArrayList; import java.util.List; @@ -48,7 +49,7 @@ record ChunkPosition(ChunkOffset offsets, int wordCount) {} @Override public List chunk(String input, ChunkingSettings chunkingSettings) { if (chunkingSettings instanceof WordBoundaryChunkingSettings wordBoundaryChunkerSettings) { - return chunk(input, wordBoundaryChunkerSettings.maxChunkSize, wordBoundaryChunkerSettings.overlap); + return chunk(input, wordBoundaryChunkerSettings.maxChunkSize(), wordBoundaryChunkerSettings.overlap()); } else { throw new IllegalArgumentException( Strings.format("WordBoundaryChunker can't use ChunkingSettings with strategy [%s]", chunkingSettings.getChunkingStrategy()) diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/mapper/SemanticTextField.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/mapper/SemanticTextField.java index b6652e499b9fc..ad802db74c181 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/mapper/SemanticTextField.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/mapper/SemanticTextField.java @@ -28,7 +28,7 @@ import org.elasticsearch.xcontent.XContentParserConfiguration; import org.elasticsearch.xcontent.XContentType; import org.elasticsearch.xcontent.support.MapXContentParser; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import java.io.IOException; import java.util.ArrayList; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/rank/textsimilarity/ChunkScorerConfig.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/rank/textsimilarity/ChunkScorerConfig.java index 92c4eace01442..4a87dab559a91 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/rank/textsimilarity/ChunkScorerConfig.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/rank/textsimilarity/ChunkScorerConfig.java @@ -11,8 +11,8 @@ import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.io.stream.Writeable; import org.elasticsearch.inference.ChunkingSettings; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; -import org.elasticsearch.xpack.inference.chunking.SentenceBoundaryChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.SentenceBoundaryChunkingSettings; import java.io.IOException; import java.util.Map; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/ServiceUtils.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/ServiceUtils.java index 2607e68acadbb..c83f890277500 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/ServiceUtils.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/ServiceUtils.java @@ -22,6 +22,7 @@ import org.elasticsearch.inference.SimilarityMeasure; import org.elasticsearch.inference.TaskType; import org.elasticsearch.rest.RestStatus; +import org.elasticsearch.xpack.core.inference.InferenceUtils; import org.elasticsearch.xpack.core.inference.action.InferenceAction; import org.elasticsearch.xpack.core.ml.inference.assignment.AdaptiveAllocationsSettings; import org.elasticsearch.xpack.inference.InferencePlugin; @@ -34,13 +35,16 @@ import java.util.EnumSet; import java.util.HashMap; import java.util.List; -import java.util.Locale; import java.util.Map; import java.util.Objects; import java.util.function.Function; import java.util.stream.Collectors; import static org.elasticsearch.core.Strings.format; +import static org.elasticsearch.xpack.core.inference.InferenceUtils.missingSettingErrorMsg; +import static org.elasticsearch.xpack.core.inference.InferenceUtils.mustBeAPositiveIntegerErrorMessage; +import static org.elasticsearch.xpack.core.inference.InferenceUtils.mustBeGreaterThanOrEqualNumberErrorMessage; +import static org.elasticsearch.xpack.core.inference.InferenceUtils.mustBeLessThanOrEqualNumberErrorMessage; import static org.elasticsearch.xpack.core.ml.inference.assignment.AdaptiveAllocationsSettings.ENABLED; import static org.elasticsearch.xpack.core.ml.inference.assignment.AdaptiveAllocationsSettings.MAX_NUMBER_OF_ALLOCATIONS; import static org.elasticsearch.xpack.core.ml.inference.assignment.AdaptiveAllocationsSettings.MIN_NUMBER_OF_ALLOCATIONS; @@ -87,22 +91,7 @@ public static T removeAsType(Map sourceMap, String key, Clas */ @SuppressWarnings("unchecked") public static T removeAsType(Map sourceMap, String key, Class type, ValidationException validationException) { - if (sourceMap == null) { - validationException.addValidationError(Strings.format("Encountered a null input map while parsing field [%s]", key)); - return null; - } - - Object o = sourceMap.remove(key); - if (o == null) { - return null; - } - - if (type.isAssignableFrom(o.getClass())) { - return (T) o; - } else { - validationException.addValidationError(invalidTypeErrorMsg(key, o, type.getSimpleName())); - return null; - } + return InferenceUtils.removeAsType(sourceMap, key, type, validationException); } /** @@ -242,10 +231,6 @@ public static ElasticsearchStatusException invalidModelTypeForUpdateModelWithCha ); } - public static String missingSettingErrorMsg(String settingName, String scope) { - return Strings.format("[%s] does not contain the required setting [%s]", scope, settingName); - } - public static String missingOneOfSettingsErrorMsg(List settingNames, String scope) { return Strings.format("[%s] does not contain one of the required settings [%s]", scope, String.join(", ", settingNames)); } @@ -409,7 +394,7 @@ public static String extractRequiredString( } if (requiredField == null) { - validationException.addValidationError(ServiceUtils.missingSettingErrorMsg(settingName, scope)); + validationException.addValidationError(missingSettingErrorMsg(settingName, scope)); } else if (requiredField.isEmpty()) { validationException.addValidationError(ServiceUtils.mustBeNonEmptyString(settingName, scope)); } @@ -439,23 +424,7 @@ public static String extractOptionalString( String scope, ValidationException validationException ) { - int initialValidationErrorCount = validationException.validationErrors().size(); - String optionalField = ServiceUtils.removeAsType(map, settingName, String.class, validationException); - - if (validationException.validationErrors().size() > initialValidationErrorCount) { - // new validation error occurred - return null; - } - - if (optionalField != null && optionalField.isEmpty()) { - validationException.addValidationError(ServiceUtils.mustBeNonEmptyString(settingName, scope)); - } - - if (validationException.validationErrors().size() > initialValidationErrorCount) { - return null; - } - - return optionalField; + return InferenceUtils.extractOptionalString(map, settingName, scope, validationException); } @SuppressWarnings("unchecked") @@ -465,26 +434,7 @@ public static List extractOptionalList( Class type, ValidationException validationException ) { - int initialValidationErrorCount = validationException.validationErrors().size(); - var optionalField = ServiceUtils.removeAsType(map, settingName, List.class, validationException); - - if (validationException.validationErrors().size() > initialValidationErrorCount) { - return null; - } - - if (optionalField != null) { - for (Object o : optionalField) { - if (o.getClass().equals(type) == false) { - validationException.addValidationError(ServiceUtils.invalidTypeErrorMsg(settingName, o, "String")); - } - } - } - - if (validationException.validationErrors().size() > initialValidationErrorCount) { - return null; - } - - return (List) optionalField; + return InferenceUtils.extractOptionalList(map, settingName, type, validationException); } public static Integer extractRequiredPositiveInteger( @@ -493,24 +443,7 @@ public static Integer extractRequiredPositiveInteger( String scope, ValidationException validationException ) { - int initialValidationErrorCount = validationException.validationErrors().size(); - Integer field = ServiceUtils.removeAsType(map, settingName, Integer.class, validationException); - - if (validationException.validationErrors().size() > initialValidationErrorCount) { - return null; - } - - if (field == null) { - validationException.addValidationError(ServiceUtils.missingSettingErrorMsg(settingName, scope)); - } else if (field <= 0) { - validationException.addValidationError(ServiceUtils.mustBeAPositiveIntegerErrorMessage(settingName, scope, field)); - } - - if (validationException.validationErrors().size() > initialValidationErrorCount) { - return null; - } - - return field; + return InferenceUtils.extractRequiredPositiveInteger(map, settingName, scope, validationException); } @SuppressWarnings("unchecked") @@ -528,7 +461,7 @@ public static Map extractRequiredMap( } if (requiredField == null) { - validationException.addValidationError(ServiceUtils.missingSettingErrorMsg(settingName, scope)); + validationException.addValidationError(missingSettingErrorMsg(settingName, scope)); } else if (requiredField.isEmpty()) { validationException.addValidationError(ServiceUtils.mustBeNonEmptyMap(settingName, scope)); } @@ -771,15 +704,7 @@ public static Integer extractRequiredPositiveIntegerLessThanOrEqualToMax( String scope, ValidationException validationException ) { - Integer field = extractRequiredPositiveInteger(map, settingName, scope, validationException); - - if (field != null && field > maxValue) { - validationException.addValidationError( - ServiceUtils.mustBeLessThanOrEqualNumberErrorMessage(settingName, scope, field, maxValue) - ); - } - - return field; + return InferenceUtils.extractRequiredPositiveIntegerLessThanOrEqualToMax(map, settingName, maxValue, scope, validationException); } public static Integer extractRequiredPositiveIntegerGreaterThanOrEqualToMin( @@ -789,16 +714,7 @@ public static Integer extractRequiredPositiveIntegerGreaterThanOrEqualToMin( String scope, ValidationException validationException ) { - Integer field = extractRequiredPositiveInteger(map, settingName, scope, validationException); - - if (field != null && field < minValue) { - validationException.addValidationError( - ServiceUtils.mustBeGreaterThanOrEqualNumberErrorMessage(settingName, scope, field, minValue) - ); - return null; - } - - return field; + return InferenceUtils.extractRequiredPositiveIntegerGreaterThanOrEqualToMin(map, settingName, minValue, scope, validationException); } public static Integer extractRequiredPositiveIntegerBetween( @@ -812,15 +728,11 @@ public static Integer extractRequiredPositiveIntegerBetween( Integer field = extractRequiredPositiveInteger(map, settingName, scope, validationException); if (field != null && field < minValue) { - validationException.addValidationError( - ServiceUtils.mustBeGreaterThanOrEqualNumberErrorMessage(settingName, scope, field, minValue) - ); + validationException.addValidationError(mustBeGreaterThanOrEqualNumberErrorMessage(settingName, scope, field, minValue)); return null; } if (field != null && field > maxValue) { - validationException.addValidationError( - ServiceUtils.mustBeLessThanOrEqualNumberErrorMessage(settingName, scope, field, maxValue) - ); + validationException.addValidationError(mustBeLessThanOrEqualNumberErrorMessage(settingName, scope, field, maxValue)); return null; } @@ -860,7 +772,7 @@ private static Integer extractOptionalInteger( } if (optionalField != null && mustBePositive && optionalField <= 0) { - validationException.addValidationError(ServiceUtils.mustBeAPositiveIntegerErrorMessage(settingName, scope, optionalField)); + validationException.addValidationError(mustBeAPositiveIntegerErrorMessage(settingName, scope, optionalField)); return null; } @@ -887,15 +799,11 @@ public static Double extractOptionalDoubleInRange( } if (doubleReturn != null && minValue != null && doubleReturn < minValue) { - validationException.addValidationError( - ServiceUtils.mustBeGreaterThanOrEqualNumberErrorMessage(settingName, scope, doubleReturn, minValue) - ); + validationException.addValidationError(mustBeGreaterThanOrEqualNumberErrorMessage(settingName, scope, doubleReturn, minValue)); } if (doubleReturn != null && maxValue != null && doubleReturn > maxValue) { - validationException.addValidationError( - ServiceUtils.mustBeLessThanOrEqualNumberErrorMessage(settingName, scope, doubleReturn, maxValue) - ); + validationException.addValidationError(mustBeLessThanOrEqualNumberErrorMessage(settingName, scope, doubleReturn, maxValue)); } if (validationException.validationErrors().size() > initialValidationErrorCount) { @@ -909,7 +817,7 @@ public static > E extractRequiredEnum( Map map, String settingName, String scope, - EnumConstructor constructor, + InferenceUtils.EnumConstructor constructor, EnumSet validValues, ValidationException validationException ) { @@ -921,7 +829,7 @@ public static > E extractRequiredEnum( } if (enumReturn == null) { - validationException.addValidationError(ServiceUtils.missingSettingErrorMsg(settingName, scope)); + validationException.addValidationError(missingSettingErrorMsg(settingName, scope)); } return enumReturn; @@ -964,26 +872,11 @@ public static > E extractOptionalEnum( Map map, String settingName, String scope, - EnumConstructor constructor, + InferenceUtils.EnumConstructor constructor, EnumSet validValues, ValidationException validationException ) { - var enumString = extractOptionalString(map, settingName, scope, validationException); - if (enumString == null) { - return null; - } - - try { - var createdEnum = constructor.apply(enumString); - validateEnumValue(createdEnum, validValues); - - return createdEnum; - } catch (IllegalArgumentException e) { - var validValuesAsStrings = validValues.stream().map(value -> value.toString().toLowerCase(Locale.ROOT)).toArray(String[]::new); - validationException.addValidationError(invalidValue(settingName, scope, enumString, validValuesAsStrings)); - } - - return null; + return InferenceUtils.extractOptionalEnum(map, settingName, scope, constructor, validValues, validationException); } public static Boolean extractOptionalBoolean(Map map, String settingName, ValidationException validationException) { @@ -1010,28 +903,6 @@ public static TimeValue extractOptionalTimeValue( return null; } - private static > void validateEnumValue(E enumValue, EnumSet validValues) { - if (validValues.contains(enumValue) == false) { - throw new IllegalArgumentException(Strings.format("Enum value [%s] is not one of the acceptable values", enumValue.toString())); - } - } - - public static String mustBeAPositiveIntegerErrorMessage(String settingName, String scope, int value) { - return format("[%s] Invalid value [%s]. [%s] must be a positive integer", scope, value, settingName); - } - - public static String mustBeLessThanOrEqualNumberErrorMessage(String settingName, String scope, double value, double maxValue) { - return format("[%s] Invalid value [%s]. [%s] must be a less than or equal to [%s]", scope, value, settingName, maxValue); - } - - public static String mustBeGreaterThanOrEqualNumberErrorMessage(String settingName, String scope, double value, double minValue) { - return format("[%s] Invalid value [%s]. [%s] must be a greater than or equal to [%s]", scope, value, settingName, minValue); - } - - public static String mustBeAFloatingPointNumberErrorMessage(String settingName, String scope) { - return format("[%s] Invalid value. [%s] must be a floating point number", scope, settingName); - } - public static String mustBeAPositiveLongErrorMessage(String settingName, String scope, Long value) { return format("[%s] Invalid value [%s]. [%s] must be a positive long", scope, value, settingName); } @@ -1070,15 +941,6 @@ public static TaskType resolveTaskType(TaskType urlTaskType, String bodyTaskType return parsedBodyTask; } - /** - * Functional interface for creating an enum from a string. - * @param - */ - @FunctionalInterface - public interface EnumConstructor> { - E apply(String name) throws IllegalArgumentException; - } - /** * Create an exception for when the task type is not valid for the service. */ diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/alibabacloudsearch/AlibabaCloudSearchService.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/alibabacloudsearch/AlibabaCloudSearchService.java index 5f2378d40116d..dc8b2c9025ca5 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/alibabacloudsearch/AlibabaCloudSearchService.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/alibabacloudsearch/AlibabaCloudSearchService.java @@ -31,7 +31,7 @@ import org.elasticsearch.inference.SimilarityMeasure; import org.elasticsearch.inference.TaskType; import org.elasticsearch.inference.configuration.SettingsConfigurationFieldType; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.chunking.EmbeddingRequestChunker; import org.elasticsearch.xpack.inference.external.http.sender.EmbeddingsInput; import org.elasticsearch.xpack.inference.external.http.sender.HttpRequestSender; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/amazonbedrock/AmazonBedrockService.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/amazonbedrock/AmazonBedrockService.java index 7f0d96c24e84b..071a0b6326c24 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/amazonbedrock/AmazonBedrockService.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/amazonbedrock/AmazonBedrockService.java @@ -32,7 +32,7 @@ import org.elasticsearch.inference.TaskType; import org.elasticsearch.inference.configuration.SettingsConfigurationFieldType; import org.elasticsearch.rest.RestStatus; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.chunking.EmbeddingRequestChunker; import org.elasticsearch.xpack.inference.common.amazon.AwsSecretSettings; import org.elasticsearch.xpack.inference.external.http.sender.EmbeddingsInput; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/amazonbedrock/embeddings/AmazonBedrockEmbeddingsServiceSettings.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/amazonbedrock/embeddings/AmazonBedrockEmbeddingsServiceSettings.java index 55b9972168278..a5e7449d6afb1 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/amazonbedrock/embeddings/AmazonBedrockEmbeddingsServiceSettings.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/amazonbedrock/embeddings/AmazonBedrockEmbeddingsServiceSettings.java @@ -15,6 +15,7 @@ import org.elasticsearch.inference.ModelConfigurations; import org.elasticsearch.inference.SimilarityMeasure; import org.elasticsearch.xcontent.XContentBuilder; +import org.elasticsearch.xpack.core.inference.InferenceUtils; import org.elasticsearch.xpack.inference.services.ConfigurationParseContext; import org.elasticsearch.xpack.inference.services.ServiceUtils; import org.elasticsearch.xpack.inference.services.amazonbedrock.AmazonBedrockProvider; @@ -89,7 +90,7 @@ private static AmazonBedrockEmbeddingsServiceSettings embeddingSettingsFromMap( case PERSISTENT -> { if (dimensionsSetByUser == null) { validationException.addValidationError( - ServiceUtils.missingSettingErrorMsg(DIMENSIONS_SET_BY_USER, ModelConfigurations.SERVICE_SETTINGS) + InferenceUtils.missingSettingErrorMsg(DIMENSIONS_SET_BY_USER, ModelConfigurations.SERVICE_SETTINGS) ); } } diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/azureaistudio/AzureAiStudioService.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/azureaistudio/AzureAiStudioService.java index 60b8bbdf86fa5..ebfc25b903205 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/azureaistudio/AzureAiStudioService.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/azureaistudio/AzureAiStudioService.java @@ -33,7 +33,7 @@ import org.elasticsearch.inference.TaskType; import org.elasticsearch.inference.configuration.SettingsConfigurationFieldType; import org.elasticsearch.rest.RestStatus; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.chunking.EmbeddingRequestChunker; import org.elasticsearch.xpack.inference.external.http.sender.EmbeddingsInput; import org.elasticsearch.xpack.inference.external.http.sender.HttpRequestSender; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/azureaistudio/embeddings/AzureAiStudioEmbeddingsServiceSettings.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/azureaistudio/embeddings/AzureAiStudioEmbeddingsServiceSettings.java index 6ae1f773853d1..f42573e4a0a31 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/azureaistudio/embeddings/AzureAiStudioEmbeddingsServiceSettings.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/azureaistudio/embeddings/AzureAiStudioEmbeddingsServiceSettings.java @@ -18,6 +18,7 @@ import org.elasticsearch.inference.SimilarityMeasure; import org.elasticsearch.xcontent.ToXContent; import org.elasticsearch.xcontent.XContentBuilder; +import org.elasticsearch.xpack.core.inference.InferenceUtils; import org.elasticsearch.xpack.inference.services.ConfigurationParseContext; import org.elasticsearch.xpack.inference.services.ServiceUtils; import org.elasticsearch.xpack.inference.services.azureaistudio.AzureAiStudioEndpointType; @@ -82,7 +83,7 @@ private static AzureAiStudioEmbeddingCommonFields embeddingSettingsFromMap( case PERSISTENT -> { if (dimensionsSetByUser == null) { validationException.addValidationError( - ServiceUtils.missingSettingErrorMsg(DIMENSIONS_SET_BY_USER, ModelConfigurations.SERVICE_SETTINGS) + InferenceUtils.missingSettingErrorMsg(DIMENSIONS_SET_BY_USER, ModelConfigurations.SERVICE_SETTINGS) ); } } diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/azureopenai/AzureOpenAiService.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/azureopenai/AzureOpenAiService.java index de067ae0096b5..5cb1c315d2b89 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/azureopenai/AzureOpenAiService.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/azureopenai/AzureOpenAiService.java @@ -29,7 +29,7 @@ import org.elasticsearch.inference.SimilarityMeasure; import org.elasticsearch.inference.TaskType; import org.elasticsearch.inference.configuration.SettingsConfigurationFieldType; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.chunking.EmbeddingRequestChunker; import org.elasticsearch.xpack.inference.external.http.sender.EmbeddingsInput; import org.elasticsearch.xpack.inference.external.http.sender.HttpRequestSender; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/azureopenai/embeddings/AzureOpenAiEmbeddingsServiceSettings.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/azureopenai/embeddings/AzureOpenAiEmbeddingsServiceSettings.java index d1842fe8a1df0..bc9c916c4ae57 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/azureopenai/embeddings/AzureOpenAiEmbeddingsServiceSettings.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/azureopenai/embeddings/AzureOpenAiEmbeddingsServiceSettings.java @@ -18,6 +18,7 @@ import org.elasticsearch.inference.ServiceSettings; import org.elasticsearch.inference.SimilarityMeasure; import org.elasticsearch.xcontent.XContentBuilder; +import org.elasticsearch.xpack.core.inference.InferenceUtils; import org.elasticsearch.xpack.inference.services.ConfigurationParseContext; import org.elasticsearch.xpack.inference.services.ServiceUtils; import org.elasticsearch.xpack.inference.services.azureopenai.AzureOpenAiRateLimitServiceSettings; @@ -118,7 +119,7 @@ private static CommonFields fromMap( case PERSISTENT -> { if (dimensionsSetByUser == null) { validationException.addValidationError( - ServiceUtils.missingSettingErrorMsg(DIMENSIONS_SET_BY_USER, ModelConfigurations.SERVICE_SETTINGS) + InferenceUtils.missingSettingErrorMsg(DIMENSIONS_SET_BY_USER, ModelConfigurations.SERVICE_SETTINGS) ); } } diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/cohere/CohereService.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/cohere/CohereService.java index b61274ac28672..bcace35b24a6a 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/cohere/CohereService.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/cohere/CohereService.java @@ -31,7 +31,7 @@ import org.elasticsearch.inference.SimilarityMeasure; import org.elasticsearch.inference.TaskType; import org.elasticsearch.inference.configuration.SettingsConfigurationFieldType; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.chunking.EmbeddingRequestChunker; import org.elasticsearch.xpack.inference.external.http.sender.EmbeddingsInput; import org.elasticsearch.xpack.inference.external.http.sender.HttpRequestSender; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/custom/CustomService.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/custom/CustomService.java index 3a57eb1b87473..944df8b6faf9d 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/custom/CustomService.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/custom/CustomService.java @@ -32,7 +32,7 @@ import org.elasticsearch.inference.TaskType; import org.elasticsearch.inference.validation.ServiceIntegrationValidator; import org.elasticsearch.rest.RestStatus; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.chunking.EmbeddingRequestChunker; import org.elasticsearch.xpack.inference.external.action.SenderExecutableAction; import org.elasticsearch.xpack.inference.external.http.sender.ChatCompletionInput; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/elastic/ElasticInferenceService.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/elastic/ElasticInferenceService.java index 9fada2a66c95d..4a14d2d540bdf 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/elastic/ElasticInferenceService.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/elastic/ElasticInferenceService.java @@ -37,11 +37,11 @@ import org.elasticsearch.rest.RestStatus; import org.elasticsearch.tasks.Task; import org.elasticsearch.xpack.core.inference.action.InferenceAction; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.core.inference.results.ChunkedInferenceEmbedding; import org.elasticsearch.xpack.core.inference.results.ChunkedInferenceError; import org.elasticsearch.xpack.core.inference.results.SparseEmbeddingResults; import org.elasticsearch.xpack.core.ml.inference.results.ErrorInferenceResults; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.chunking.EmbeddingRequestChunker; import org.elasticsearch.xpack.inference.external.action.SenderExecutableAction; import org.elasticsearch.xpack.inference.external.http.sender.EmbeddingsInput; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/elasticsearch/ElasticsearchInternalService.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/elasticsearch/ElasticsearchInternalService.java index 2c1ee96b519a3..67af79d11d967 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/elasticsearch/ElasticsearchInternalService.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/elasticsearch/ElasticsearchInternalService.java @@ -38,6 +38,7 @@ import org.elasticsearch.inference.configuration.SettingsConfigurationFieldType; import org.elasticsearch.rest.RestStatus; import org.elasticsearch.xpack.core.XPackSettings; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.core.inference.results.RankedDocsResults; import org.elasticsearch.xpack.core.inference.results.SparseEmbeddingResults; import org.elasticsearch.xpack.core.inference.results.TextEmbeddingFloatResults; @@ -56,7 +57,6 @@ import org.elasticsearch.xpack.core.ml.inference.trainedmodel.TextExpansionConfigUpdate; import org.elasticsearch.xpack.core.ml.inference.trainedmodel.TextSimilarityConfig; import org.elasticsearch.xpack.core.ml.inference.trainedmodel.TextSimilarityConfigUpdate; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.chunking.EmbeddingRequestChunker; import org.elasticsearch.xpack.inference.chunking.RerankRequestChunker; import org.elasticsearch.xpack.inference.services.ConfigurationParseContext; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/googleaistudio/GoogleAiStudioService.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/googleaistudio/GoogleAiStudioService.java index dc08ec8544e3c..8dce7e6f229f4 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/googleaistudio/GoogleAiStudioService.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/googleaistudio/GoogleAiStudioService.java @@ -30,7 +30,7 @@ import org.elasticsearch.inference.SimilarityMeasure; import org.elasticsearch.inference.TaskType; import org.elasticsearch.inference.configuration.SettingsConfigurationFieldType; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.chunking.EmbeddingRequestChunker; import org.elasticsearch.xpack.inference.external.action.SenderExecutableAction; import org.elasticsearch.xpack.inference.external.action.SingleInputSenderExecutableAction; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/googlevertexai/GoogleVertexAiService.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/googlevertexai/GoogleVertexAiService.java index 117bed24dfbbe..27b2530f3633a 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/googlevertexai/GoogleVertexAiService.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/googlevertexai/GoogleVertexAiService.java @@ -30,7 +30,7 @@ import org.elasticsearch.inference.SettingsConfiguration; import org.elasticsearch.inference.TaskType; import org.elasticsearch.inference.configuration.SettingsConfigurationFieldType; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.chunking.EmbeddingRequestChunker; import org.elasticsearch.xpack.inference.external.action.SenderExecutableAction; import org.elasticsearch.xpack.inference.external.http.sender.EmbeddingsInput; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/googlevertexai/embeddings/GoogleVertexAiEmbeddingsServiceSettings.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/googlevertexai/embeddings/GoogleVertexAiEmbeddingsServiceSettings.java index d00644a1140d4..932c436bdb757 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/googlevertexai/embeddings/GoogleVertexAiEmbeddingsServiceSettings.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/googlevertexai/embeddings/GoogleVertexAiEmbeddingsServiceSettings.java @@ -18,6 +18,7 @@ import org.elasticsearch.inference.ServiceSettings; import org.elasticsearch.inference.SimilarityMeasure; import org.elasticsearch.xcontent.XContentBuilder; +import org.elasticsearch.xpack.core.inference.InferenceUtils; import org.elasticsearch.xpack.inference.services.ConfigurationParseContext; import org.elasticsearch.xpack.inference.services.ServiceUtils; import org.elasticsearch.xpack.inference.services.googlevertexai.GoogleVertexAiRateLimitServiceSettings; @@ -88,7 +89,7 @@ public static GoogleVertexAiEmbeddingsServiceSettings fromMap(Map { if (dimensionsSetByUser == null) { validationException.addValidationError( - ServiceUtils.missingSettingErrorMsg(DIMENSIONS_SET_BY_USER, ModelConfigurations.SERVICE_SETTINGS) + InferenceUtils.missingSettingErrorMsg(DIMENSIONS_SET_BY_USER, ModelConfigurations.SERVICE_SETTINGS) ); } } diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/huggingface/HuggingFaceBaseService.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/huggingface/HuggingFaceBaseService.java index 403a1758983ac..19f5792a8d944 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/huggingface/HuggingFaceBaseService.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/huggingface/HuggingFaceBaseService.java @@ -19,7 +19,7 @@ import org.elasticsearch.inference.ModelConfigurations; import org.elasticsearch.inference.ModelSecrets; import org.elasticsearch.inference.TaskType; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.external.http.sender.HttpRequestSender; import org.elasticsearch.xpack.inference.external.http.sender.InferenceInputs; import org.elasticsearch.xpack.inference.services.ConfigurationParseContext; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/ibmwatsonx/IbmWatsonxService.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/ibmwatsonx/IbmWatsonxService.java index ee836d03747de..2ff50b52a7fe9 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/ibmwatsonx/IbmWatsonxService.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/ibmwatsonx/IbmWatsonxService.java @@ -29,7 +29,7 @@ import org.elasticsearch.inference.SimilarityMeasure; import org.elasticsearch.inference.TaskType; import org.elasticsearch.inference.configuration.SettingsConfigurationFieldType; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.chunking.EmbeddingRequestChunker; import org.elasticsearch.xpack.inference.external.action.SenderExecutableAction; import org.elasticsearch.xpack.inference.external.http.retry.ResponseHandler; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/jinaai/JinaAIService.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/jinaai/JinaAIService.java index c42a67eb3186b..345e873694a5f 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/jinaai/JinaAIService.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/jinaai/JinaAIService.java @@ -29,7 +29,7 @@ import org.elasticsearch.inference.SimilarityMeasure; import org.elasticsearch.inference.TaskType; import org.elasticsearch.inference.configuration.SettingsConfigurationFieldType; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.chunking.EmbeddingRequestChunker; import org.elasticsearch.xpack.inference.external.http.sender.EmbeddingsInput; import org.elasticsearch.xpack.inference.external.http.sender.HttpRequestSender; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/llama/LlamaService.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/llama/LlamaService.java index b3c0e12927fff..58b0219a0369a 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/llama/LlamaService.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/llama/LlamaService.java @@ -27,7 +27,7 @@ import org.elasticsearch.inference.SimilarityMeasure; import org.elasticsearch.inference.TaskType; import org.elasticsearch.inference.configuration.SettingsConfigurationFieldType; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.chunking.EmbeddingRequestChunker; import org.elasticsearch.xpack.inference.external.action.SenderExecutableAction; import org.elasticsearch.xpack.inference.external.http.retry.ResponseHandler; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/mistral/MistralService.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/mistral/MistralService.java index 2bed18eb99b11..788ce8385d207 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/mistral/MistralService.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/mistral/MistralService.java @@ -29,7 +29,7 @@ import org.elasticsearch.inference.SimilarityMeasure; import org.elasticsearch.inference.TaskType; import org.elasticsearch.inference.configuration.SettingsConfigurationFieldType; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.chunking.EmbeddingRequestChunker; import org.elasticsearch.xpack.inference.external.action.SenderExecutableAction; import org.elasticsearch.xpack.inference.external.http.retry.ResponseHandler; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/openai/OpenAiService.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/openai/OpenAiService.java index 9e77c0d63e336..897a349d3af94 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/openai/OpenAiService.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/openai/OpenAiService.java @@ -32,7 +32,7 @@ import org.elasticsearch.inference.configuration.SettingsConfigurationFieldType; import org.elasticsearch.rest.RestStatus; import org.elasticsearch.xpack.core.inference.action.InferenceAction; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.chunking.EmbeddingRequestChunker; import org.elasticsearch.xpack.inference.external.action.SenderExecutableAction; import org.elasticsearch.xpack.inference.external.http.retry.ResponseHandler; diff --git a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/voyageai/VoyageAIService.java b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/voyageai/VoyageAIService.java index 24d82eb764498..4b549a13ff36d 100644 --- a/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/voyageai/VoyageAIService.java +++ b/x-pack/plugin/inference/src/main/java/org/elasticsearch/xpack/inference/services/voyageai/VoyageAIService.java @@ -29,7 +29,7 @@ import org.elasticsearch.inference.SimilarityMeasure; import org.elasticsearch.inference.TaskType; import org.elasticsearch.inference.configuration.SettingsConfigurationFieldType; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.chunking.EmbeddingRequestChunker; import org.elasticsearch.xpack.inference.external.http.sender.EmbeddingsInput; import org.elasticsearch.xpack.inference.external.http.sender.HttpRequestSender; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/ModelConfigurationsTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/ModelConfigurationsTests.java index 732e2cc826570..535db113396a2 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/ModelConfigurationsTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/ModelConfigurationsTests.java @@ -14,10 +14,14 @@ import org.elasticsearch.inference.TaskSettings; import org.elasticsearch.inference.TaskType; import org.elasticsearch.test.AbstractWireSerializingTestCase; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests; +import org.elasticsearch.xpack.core.XPackClientPlugin; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests; import org.elasticsearch.xpack.inference.services.elasticsearch.ElserInternalServiceSettingsTests; import org.elasticsearch.xpack.inference.services.elasticsearch.ElserMlNodeTaskSettings; +import java.util.ArrayList; +import java.util.List; + public class ModelConfigurationsTests extends AbstractWireSerializingTestCase { public static ModelConfigurations createRandomInstance() { @@ -70,7 +74,10 @@ private static TaskSettings randomTaskSettings(TaskType taskType) { @Override protected NamedWriteableRegistry getNamedWriteableRegistry() { - return new NamedWriteableRegistry(InferenceNamedWriteablesProvider.getNamedWriteables()); + List namedWriteables = new ArrayList<>(InferenceNamedWriteablesProvider.getNamedWriteables()); + namedWriteables.addAll(XPackClientPlugin.getChunkingSettingsNamedWriteables()); + + return new NamedWriteableRegistry(namedWriteables); } @Override @@ -87,4 +94,5 @@ protected ModelConfigurations createTestInstance() { protected ModelConfigurations mutateInstance(ModelConfigurations instance) { return mutateTestInstance(instance); } + } diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/action/GetInferenceModelResponseTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/action/GetInferenceModelResponseTests.java index 7beff9125d157..b5616438818c0 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/action/GetInferenceModelResponseTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/action/GetInferenceModelResponseTests.java @@ -11,12 +11,14 @@ import org.elasticsearch.common.io.stream.Writeable; import org.elasticsearch.inference.ModelConfigurations; import org.elasticsearch.test.AbstractWireSerializingTestCase; +import org.elasticsearch.xpack.core.XPackClientPlugin; import org.elasticsearch.xpack.core.inference.action.GetInferenceModelAction; import org.elasticsearch.xpack.inference.InferenceNamedWriteablesProvider; import org.elasticsearch.xpack.inference.ModelConfigurationsTests; import java.io.IOException; import java.util.ArrayList; +import java.util.List; public class GetInferenceModelResponseTests extends AbstractWireSerializingTestCase { @Override @@ -43,6 +45,9 @@ protected GetInferenceModelAction.Response mutateInstance(GetInferenceModelActio @Override protected NamedWriteableRegistry getNamedWriteableRegistry() { - return new NamedWriteableRegistry(InferenceNamedWriteablesProvider.getNamedWriteables()); + List namedWriteables = new ArrayList<>(InferenceNamedWriteablesProvider.getNamedWriteables()); + namedWriteables.addAll(XPackClientPlugin.getChunkingSettingsNamedWriteables()); + + return new NamedWriteableRegistry(namedWriteables); } } diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/action/PutInferenceModelResponseTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/action/PutInferenceModelResponseTests.java index d88aa91ff5148..62e8c48234671 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/action/PutInferenceModelResponseTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/action/PutInferenceModelResponseTests.java @@ -10,10 +10,14 @@ import org.elasticsearch.common.io.stream.NamedWriteableRegistry; import org.elasticsearch.common.io.stream.Writeable; import org.elasticsearch.test.AbstractWireSerializingTestCase; +import org.elasticsearch.xpack.core.XPackClientPlugin; import org.elasticsearch.xpack.core.inference.action.PutInferenceModelAction; import org.elasticsearch.xpack.inference.InferenceNamedWriteablesProvider; import org.elasticsearch.xpack.inference.ModelConfigurationsTests; +import java.util.ArrayList; +import java.util.List; + public class PutInferenceModelResponseTests extends AbstractWireSerializingTestCase { @Override @@ -36,6 +40,9 @@ protected Writeable.Reader instanceReader() { @Override protected NamedWriteableRegistry getNamedWriteableRegistry() { - return new NamedWriteableRegistry(InferenceNamedWriteablesProvider.getNamedWriteables()); + List namedWriteables = new ArrayList<>(InferenceNamedWriteablesProvider.getNamedWriteables()); + namedWriteables.addAll(XPackClientPlugin.getChunkingSettingsNamedWriteables()); + + return new NamedWriteableRegistry(namedWriteables); } } diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/action/UpdateInferenceModelActionResponseTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/action/UpdateInferenceModelActionResponseTests.java index 02208511d1484..d41dfc108ba26 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/action/UpdateInferenceModelActionResponseTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/action/UpdateInferenceModelActionResponseTests.java @@ -10,11 +10,14 @@ import org.elasticsearch.common.io.stream.NamedWriteableRegistry; import org.elasticsearch.common.io.stream.Writeable; import org.elasticsearch.test.AbstractWireSerializingTestCase; +import org.elasticsearch.xpack.core.XPackClientPlugin; import org.elasticsearch.xpack.core.inference.action.UpdateInferenceModelAction; import org.elasticsearch.xpack.inference.InferenceNamedWriteablesProvider; import org.elasticsearch.xpack.inference.ModelConfigurationsTests; import java.io.IOException; +import java.util.ArrayList; +import java.util.List; public class UpdateInferenceModelActionResponseTests extends AbstractWireSerializingTestCase { @Override @@ -34,6 +37,9 @@ protected UpdateInferenceModelAction.Response mutateInstance(UpdateInferenceMode @Override protected NamedWriteableRegistry getNamedWriteableRegistry() { - return new NamedWriteableRegistry(InferenceNamedWriteablesProvider.getNamedWriteables()); + List namedWriteables = new ArrayList<>(InferenceNamedWriteablesProvider.getNamedWriteables()); + namedWriteables.addAll(XPackClientPlugin.getChunkingSettingsNamedWriteables()); + + return new NamedWriteableRegistry(namedWriteables); } } diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/ChunkingSettingsBuilderTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/ChunkingSettingsBuilderTests.java index 0b4923170a2eb..d09d36dda9e8a 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/ChunkingSettingsBuilderTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/ChunkingSettingsBuilderTests.java @@ -10,14 +10,18 @@ import org.elasticsearch.inference.ChunkingSettings; import org.elasticsearch.inference.ChunkingStrategy; import org.elasticsearch.test.ESTestCase; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsOptions; +import org.elasticsearch.xpack.core.inference.chunking.SentenceBoundaryChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.WordBoundaryChunkingSettings; import java.util.Collections; import java.util.HashMap; import java.util.Map; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder.ELASTIC_RERANKER_EXTRA_TOKEN_COUNT; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder.ELASTIC_RERANKER_TOKEN_LIMIT; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder.WORDS_PER_TOKEN; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder.ELASTIC_RERANKER_EXTRA_TOKEN_COUNT; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder.ELASTIC_RERANKER_TOKEN_LIMIT; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder.WORDS_PER_TOKEN; public class ChunkingSettingsBuilderTests extends ESTestCase { @@ -61,8 +65,8 @@ public void testBuildChunkingSettingsForElasticReranker_QueryTokenCountLessThanH SentenceBoundaryChunkingSettings sentenceBoundaryChunkingSettings = (SentenceBoundaryChunkingSettings) chunkingSettings; int expectedMaxChunkSize = (int) ((ELASTIC_RERANKER_TOKEN_LIMIT - ELASTIC_RERANKER_EXTRA_TOKEN_COUNT - queryTokenCount) * WORDS_PER_TOKEN); - assertEquals(expectedMaxChunkSize, sentenceBoundaryChunkingSettings.maxChunkSize); - assertEquals(1, sentenceBoundaryChunkingSettings.sentenceOverlap); + assertEquals(expectedMaxChunkSize, (int) sentenceBoundaryChunkingSettings.maxChunkSize()); + assertEquals(1, sentenceBoundaryChunkingSettings.sentenceOverlap()); } public void testBuildChunkingSettingsForElasticReranker_QueryTokenCountMoreThanHalfOfTokenLimit() { @@ -73,8 +77,8 @@ public void testBuildChunkingSettingsForElasticReranker_QueryTokenCountMoreThanH assertTrue(chunkingSettings instanceof SentenceBoundaryChunkingSettings); SentenceBoundaryChunkingSettings sentenceBoundaryChunkingSettings = (SentenceBoundaryChunkingSettings) chunkingSettings; int expectedMaxChunkSize = (int) (Math.floor((float) ELASTIC_RERANKER_TOKEN_LIMIT / 2) * WORDS_PER_TOKEN); - assertEquals(expectedMaxChunkSize, sentenceBoundaryChunkingSettings.maxChunkSize); - assertEquals(1, sentenceBoundaryChunkingSettings.sentenceOverlap); + assertEquals(expectedMaxChunkSize, (int) sentenceBoundaryChunkingSettings.maxChunkSize()); + assertEquals(1, sentenceBoundaryChunkingSettings.sentenceOverlap()); } private Map, ChunkingSettings> chunkingSettingsMapToChunkingSettings() { diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/EmbeddingRequestChunkerTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/EmbeddingRequestChunkerTests.java index 411d992adfa3d..2b1be9654e9bc 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/EmbeddingRequestChunkerTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/EmbeddingRequestChunkerTests.java @@ -12,6 +12,9 @@ import org.elasticsearch.inference.ChunkedInference; import org.elasticsearch.inference.WeightedToken; import org.elasticsearch.test.ESTestCase; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests; +import org.elasticsearch.xpack.core.inference.chunking.NoneChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.SentenceBoundaryChunkingSettings; import org.elasticsearch.xpack.core.inference.results.ChunkedInferenceEmbedding; import org.elasticsearch.xpack.core.inference.results.ChunkedInferenceError; import org.elasticsearch.xpack.core.inference.results.SparseEmbeddingResults; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/RecursiveChunkerTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/RecursiveChunkerTests.java index 1cb90b11995fc..2c2663ff6f04d 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/RecursiveChunkerTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/RecursiveChunkerTests.java @@ -9,6 +9,9 @@ import org.elasticsearch.inference.ChunkingSettings; import org.elasticsearch.test.ESTestCase; +import org.elasticsearch.xpack.core.inference.chunking.RecursiveChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.SentenceBoundaryChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.SeparatorGroup; import java.util.ArrayList; import java.util.List; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/SentenceBoundaryChunkerTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/SentenceBoundaryChunkerTests.java index 841c9188bc6b1..542fe496a0222 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/SentenceBoundaryChunkerTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/SentenceBoundaryChunkerTests.java @@ -11,6 +11,8 @@ import org.elasticsearch.inference.ChunkingSettings; import org.elasticsearch.test.ESTestCase; +import org.elasticsearch.xpack.core.inference.chunking.SentenceBoundaryChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.WordBoundaryChunkingSettings; import org.hamcrest.Matchers; import java.util.ArrayList; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/WordBoundaryChunkerTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/WordBoundaryChunkerTests.java index 65d9645daca4f..ee5e006383120 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/WordBoundaryChunkerTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/chunking/WordBoundaryChunkerTests.java @@ -11,6 +11,9 @@ import org.elasticsearch.inference.ChunkingSettings; import org.elasticsearch.test.ESTestCase; +import org.elasticsearch.xpack.core.inference.chunking.NoneChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.SentenceBoundaryChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.WordBoundaryChunkingSettings; import org.hamcrest.Matchers; import java.util.List; @@ -291,7 +294,7 @@ private void assertExpectedNumberOfChunksWithWordBoundaryChunkingSettings( WordBoundaryChunkingSettings chunkingSettings ) { var chunks = new WordBoundaryChunker().chunk(input, chunkingSettings); - int expected = expectedNumberOfChunks(numWords, chunkingSettings.maxChunkSize, chunkingSettings.overlap); + int expected = expectedNumberOfChunks(numWords, chunkingSettings.maxChunkSize(), chunkingSettings.overlap()); assertEquals(expected, chunks.size()); } diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/mapper/SemanticTextFieldTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/mapper/SemanticTextFieldTests.java index d1499f4009d0a..3b318f77c7e24 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/mapper/SemanticTextFieldTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/mapper/SemanticTextFieldTests.java @@ -24,15 +24,15 @@ import org.elasticsearch.xcontent.XContentParser; import org.elasticsearch.xcontent.XContentParserConfiguration; import org.elasticsearch.xcontent.XContentType; +import org.elasticsearch.xpack.core.inference.chunking.NoneChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.SentenceBoundaryChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.WordBoundaryChunkingSettings; import org.elasticsearch.xpack.core.inference.results.ChunkedInferenceEmbedding; import org.elasticsearch.xpack.core.inference.results.EmbeddingResults; import org.elasticsearch.xpack.core.inference.results.SparseEmbeddingResults; import org.elasticsearch.xpack.core.inference.results.TextEmbeddingByteResults; import org.elasticsearch.xpack.core.inference.results.TextEmbeddingFloatResults; import org.elasticsearch.xpack.core.utils.FloatConversionUtils; -import org.elasticsearch.xpack.inference.chunking.NoneChunkingSettings; -import org.elasticsearch.xpack.inference.chunking.SentenceBoundaryChunkingSettings; -import org.elasticsearch.xpack.inference.chunking.WordBoundaryChunkingSettings; import org.elasticsearch.xpack.inference.model.TestModel; import java.io.IOException; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/model/TestModel.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/model/TestModel.java index d5ba1859d8c5d..f99e8ce562b42 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/model/TestModel.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/model/TestModel.java @@ -23,6 +23,7 @@ import org.elasticsearch.inference.TaskType; import org.elasticsearch.xcontent.ToXContentObject; import org.elasticsearch.xcontent.XContentBuilder; +import org.elasticsearch.xpack.core.inference.InferenceUtils; import org.elasticsearch.xpack.inference.services.ServiceUtils; import java.io.IOException; @@ -142,7 +143,9 @@ public static TestServiceSettings fromMap(Map map) { String model = ServiceUtils.removeAsType(map, "model", String.class); if (model == null) { - validationException.addValidationError(ServiceUtils.missingSettingErrorMsg("model", ModelConfigurations.SERVICE_SETTINGS)); + validationException.addValidationError( + InferenceUtils.missingSettingErrorMsg("model", ModelConfigurations.SERVICE_SETTINGS) + ); } if (validationException.validationErrors().isEmpty() == false) { @@ -281,7 +284,7 @@ public static TestSecretSettings fromMap(Map map) { String apiKey = ServiceUtils.removeAsType(map, "api_key", String.class); if (apiKey == null) { - validationException.addValidationError(ServiceUtils.missingSettingErrorMsg("api_key", ModelSecrets.SECRET_SETTINGS)); + validationException.addValidationError(InferenceUtils.missingSettingErrorMsg("api_key", ModelSecrets.SECRET_SETTINGS)); } if (validationException.validationErrors().isEmpty() == false) { diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/AbstractInferenceServiceParameterizedTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/AbstractInferenceServiceParameterizedTests.java index 37ba073407df8..7ff3229dd92ec 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/AbstractInferenceServiceParameterizedTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/AbstractInferenceServiceParameterizedTests.java @@ -15,8 +15,8 @@ import org.elasticsearch.inference.Model; import org.elasticsearch.inference.ModelConfigurations; import org.elasticsearch.inference.TaskType; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.Utils; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; import org.junit.Assume; import java.io.IOException; @@ -24,8 +24,8 @@ import java.util.Map; import java.util.function.Function; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.Utils.getPersistedConfigMap; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.hamcrest.Matchers.containsString; import static org.hamcrest.Matchers.is; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/AbstractInferenceServiceTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/AbstractInferenceServiceTests.java index 9479a8ea6e10d..efa97a1a3b95f 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/AbstractInferenceServiceTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/AbstractInferenceServiceTests.java @@ -16,7 +16,7 @@ import org.elasticsearch.inference.SimilarityMeasure; import org.elasticsearch.inference.TaskType; import org.elasticsearch.xpack.core.inference.action.InferenceAction; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.junit.Assume; import java.io.IOException; @@ -24,10 +24,10 @@ import java.util.List; import java.util.Map; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.Utils.TIMEOUT; import static org.elasticsearch.xpack.inference.Utils.getInvalidModel; import static org.elasticsearch.xpack.inference.Utils.getRequestConfigMap; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.hamcrest.Matchers.containsString; import static org.hamcrest.Matchers.is; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/ServiceUtilsTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/ServiceUtilsTests.java index 197f8375360fb..321dcd7f776c5 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/ServiceUtilsTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/ServiceUtilsTests.java @@ -30,9 +30,7 @@ import static org.elasticsearch.xpack.inference.services.ServiceUtils.convertMapStringsToSecureString; import static org.elasticsearch.xpack.inference.services.ServiceUtils.convertToUri; import static org.elasticsearch.xpack.inference.services.ServiceUtils.createUri; -import static org.elasticsearch.xpack.inference.services.ServiceUtils.extractOptionalEnum; import static org.elasticsearch.xpack.inference.services.ServiceUtils.extractOptionalInteger; -import static org.elasticsearch.xpack.inference.services.ServiceUtils.extractOptionalList; import static org.elasticsearch.xpack.inference.services.ServiceUtils.extractOptionalListOfStringTuples; import static org.elasticsearch.xpack.inference.services.ServiceUtils.extractOptionalMap; import static org.elasticsearch.xpack.inference.services.ServiceUtils.extractOptionalMapRemoveNulls; @@ -41,9 +39,6 @@ import static org.elasticsearch.xpack.inference.services.ServiceUtils.extractOptionalString; import static org.elasticsearch.xpack.inference.services.ServiceUtils.extractOptionalTimeValue; import static org.elasticsearch.xpack.inference.services.ServiceUtils.extractRequiredMap; -import static org.elasticsearch.xpack.inference.services.ServiceUtils.extractRequiredPositiveInteger; -import static org.elasticsearch.xpack.inference.services.ServiceUtils.extractRequiredPositiveIntegerGreaterThanOrEqualToMin; -import static org.elasticsearch.xpack.inference.services.ServiceUtils.extractRequiredPositiveIntegerLessThanOrEqualToMax; import static org.elasticsearch.xpack.inference.services.ServiceUtils.extractRequiredSecureString; import static org.elasticsearch.xpack.inference.services.ServiceUtils.extractRequiredString; import static org.elasticsearch.xpack.inference.services.ServiceUtils.removeNullValues; @@ -79,21 +74,6 @@ public void testRemoveAsTypeWithTheCorrectType() { assertThat(map.entrySet(), empty()); } - public void testRemoveAsType_Validation_WithTheCorrectType() { - Map map = new HashMap<>(Map.of("a", 5, "b", "a string", "c", Boolean.TRUE, "d", 1.0)); - - ValidationException validationException = new ValidationException(); - Integer i = ServiceUtils.removeAsType(map, "a", Integer.class, validationException); - assertEquals(Integer.valueOf(5), i); - assertNull(map.get("a")); // field has been removed - assertThat(validationException.validationErrors(), empty()); - - String str = ServiceUtils.removeAsType(map, "b", String.class, validationException); - assertEquals("a string", str); - assertNull(map.get("b")); - assertThat(validationException.validationErrors(), empty()); - } - public void testRemoveAsTypeWithInCorrectType() { Map map = new HashMap<>(Map.of("a", 5, "b", "a string", "c", Boolean.TRUE, "d", 5.0, "e", 5)); @@ -137,63 +117,6 @@ public void testRemoveAsTypeWithInCorrectType() { assertThat(map.entrySet(), empty()); } - public void testRemoveAsType_Validation_WithInCorrectType() { - Map map = new HashMap<>(Map.of("a", 5, "b", "a string", "c", Boolean.TRUE, "d", 5.0, "e", 5)); - - var validationException = new ValidationException(); - Object result = ServiceUtils.removeAsType(map, "a", String.class, validationException); - assertNull(result); - assertThat(validationException.validationErrors(), hasSize(1)); - assertThat( - validationException.validationErrors().get(0), - containsString("field [a] is not of the expected type. The value [5] cannot be converted to a [String]") - ); - assertNull(map.get("a")); - - validationException = new ValidationException(); - ServiceUtils.removeAsType(map, "b", Boolean.class, validationException); - assertThat(validationException.validationErrors(), hasSize(1)); - assertThat( - validationException.validationErrors().get(0), - containsString("field [b] is not of the expected type. The value [a string] cannot be converted to a [Boolean]") - ); - assertNull(map.get("b")); - - validationException = new ValidationException(); - result = ServiceUtils.removeAsType(map, "c", Integer.class, validationException); - assertNull(result); - assertThat(validationException.validationErrors(), hasSize(1)); - assertThat( - validationException.validationErrors().get(0), - containsString("field [c] is not of the expected type. The value [true] cannot be converted to a [Integer]") - ); - assertNull(map.get("c")); - - // cannot convert double to integer - validationException = new ValidationException(); - result = ServiceUtils.removeAsType(map, "d", Integer.class, validationException); - assertNull(result); - assertThat(validationException.validationErrors(), hasSize(1)); - assertThat( - validationException.validationErrors().get(0), - containsString("field [d] is not of the expected type. The value [5.0] cannot be converted to a [Integer]") - ); - assertNull(map.get("d")); - - // cannot convert integer to double - validationException = new ValidationException(); - result = ServiceUtils.removeAsType(map, "e", Double.class, validationException); - assertNull(result); - assertThat(validationException.validationErrors(), hasSize(1)); - assertThat( - validationException.validationErrors().get(0), - containsString("field [e] is not of the expected type. The value [5] cannot be converted to a [Double]") - ); - assertNull(map.get("e")); - - assertThat(map.entrySet(), empty()); - } - public void testRemoveAsTypeMissingReturnsNull() { Map map = new HashMap<>(Map.of("a", 5, "b", "a string", "c", Boolean.TRUE)); assertNull(ServiceUtils.removeAsType(map, "missing", Integer.class)); @@ -483,94 +406,6 @@ public void testExtractRequiredString_AddsException_WhenFieldIsEmpty() { assertThat(validation.validationErrors().get(1), is("[scope] Invalid value empty string. [key] must be a non-empty string")); } - public void testExtractOptionalString_CreatesString() { - var validation = new ValidationException(); - Map map = modifiableMap(Map.of("key", "value")); - var createdString = extractOptionalString(map, "key", "scope", validation); - - assertTrue(validation.validationErrors().isEmpty()); - assertNotNull(createdString); - assertThat(createdString, is("value")); - assertTrue(map.isEmpty()); - } - - public void testExtractOptionalString_DoesNotAddException_WhenFieldDoesNotExist() { - var validation = new ValidationException(); - validation.addValidationError("previous error"); - Map map = modifiableMap(Map.of("key", "value")); - var createdString = extractOptionalString(map, "abc", "scope", validation); - - assertNull(createdString); - assertThat(validation.validationErrors(), hasSize(1)); - assertThat(map.size(), is(1)); - } - - public void testExtractOptionalString_AddsException_WhenFieldIsEmpty() { - var validation = new ValidationException(); - Map map = modifiableMap(Map.of("key", "")); - var createdString = extractOptionalString(map, "key", "scope", validation); - - assertNull(createdString); - assertFalse(validation.validationErrors().isEmpty()); - assertTrue(map.isEmpty()); - assertThat(validation.validationErrors().get(0), is("[scope] Invalid value empty string. [key] must be a non-empty string")); - } - - public void testExtractOptionalList_CreatesList() { - var validation = new ValidationException(); - var list = List.of(randomAlphaOfLength(10), randomAlphaOfLength(10)); - - Map map = modifiableMap(Map.of("key", list)); - assertEquals(list, extractOptionalList(map, "key", String.class, validation)); - assertTrue(validation.validationErrors().isEmpty()); - assertTrue(map.isEmpty()); - } - - public void testExtractOptionalList_AddsException_WhenFieldDoesNotExist() { - var validation = new ValidationException(); - validation.addValidationError("previous error"); - Map map = modifiableMap(Map.of("key", List.of(randomAlphaOfLength(10), randomAlphaOfLength(10)))); - assertNull(extractOptionalList(map, "abc", String.class, validation)); - assertThat(validation.validationErrors(), hasSize(1)); - assertThat(map.size(), is(1)); - } - - public void testExtractOptionalList_AddsException_WhenFieldIsEmpty() { - var validation = new ValidationException(); - validation.addValidationError("previous error"); - Map map = modifiableMap(Map.of("key", "")); - assertNull(extractOptionalList(map, "key", String.class, validation)); - assertFalse(validation.validationErrors().isEmpty()); - assertTrue(map.isEmpty()); - } - - public void testExtractOptionalList_AddsException_WhenFieldIsNotAList() { - var validation = new ValidationException(); - validation.addValidationError("previous error"); - Map map = modifiableMap(Map.of("key", 1)); - assertNull(extractOptionalList(map, "key", String.class, validation)); - assertFalse(validation.validationErrors().isEmpty()); - assertTrue(map.isEmpty()); - } - - public void testExtractOptionalList_AddsException_WhenFieldIsNotAListOfTheCorrectType() { - var validation = new ValidationException(); - validation.addValidationError("previous error"); - Map map = modifiableMap(Map.of("key", List.of(1, 2))); - assertNull(extractOptionalList(map, "key", String.class, validation)); - assertFalse(validation.validationErrors().isEmpty()); - assertTrue(map.isEmpty()); - } - - public void testExtractOptionalList_AddsException_WhenFieldContainsMixedTypeValues() { - var validation = new ValidationException(); - validation.addValidationError("previous error"); - Map map = modifiableMap(Map.of("key", List.of(1, "a"))); - assertNull(extractOptionalList(map, "key", String.class, validation)); - assertFalse(validation.validationErrors().isEmpty()); - assertTrue(map.isEmpty()); - } - public void testExtractOptionalPositiveInteger_returnsInteger_withPositiveInteger() { var validation = new ValidationException(); validation.addValidationError("previous error"); @@ -666,162 +501,6 @@ public void testExtractOptionalPositiveLong() { assertThat(validation.validationErrors(), hasSize(1)); } - public void testExtractRequiredPositiveInteger_ReturnsValue() { - var validation = new ValidationException(); - validation.addValidationError("previous error"); - Map map = modifiableMap(Map.of("key", 1)); - var parsedInt = extractRequiredPositiveInteger(map, "key", "scope", validation); - - assertThat(validation.validationErrors(), hasSize(1)); - assertNotNull(parsedInt); - assertThat(parsedInt, is(1)); - assertTrue(map.isEmpty()); - } - - public void testExtractRequiredPositiveInteger_AddsErrorForNegativeValue() { - var validation = new ValidationException(); - validation.addValidationError("previous error"); - Map map = modifiableMap(Map.of("key", -1)); - var parsedInt = extractRequiredPositiveInteger(map, "key", "scope", validation); - - assertThat(validation.validationErrors(), hasSize(2)); - assertNull(parsedInt); - assertTrue(map.isEmpty()); - assertThat(validation.validationErrors().get(1), is("[scope] Invalid value [-1]. [key] must be a positive integer")); - } - - public void testExtractRequiredPositiveInteger_AddsErrorWhenKeyIsMissing() { - var validation = new ValidationException(); - validation.addValidationError("previous error"); - Map map = modifiableMap(Map.of("key", -1)); - var parsedInt = extractRequiredPositiveInteger(map, "not_key", "scope", validation); - - assertThat(validation.validationErrors(), hasSize(2)); - assertNull(parsedInt); - assertThat(validation.validationErrors().get(1), is("[scope] does not contain the required setting [not_key]")); - } - - public void testExtractRequiredPositiveIntegerLessThanOrEqualToMax_ReturnsValueWhenValueIsLessThanMax() { - var validation = new ValidationException(); - validation.addValidationError("previous error"); - Map map = modifiableMap(Map.of("key", 1)); - var parsedInt = extractRequiredPositiveIntegerLessThanOrEqualToMax(map, "key", 5, "scope", validation); - - assertThat(validation.validationErrors(), hasSize(1)); - assertNotNull(parsedInt); - assertThat(parsedInt, is(1)); - assertTrue(map.isEmpty()); - } - - public void testExtractRequiredPositiveIntegerLessThanOrEqualToMax_ReturnsValueWhenValueIsEqualToMax() { - var validation = new ValidationException(); - validation.addValidationError("previous error"); - Map map = modifiableMap(Map.of("key", 5)); - var parsedInt = extractRequiredPositiveIntegerLessThanOrEqualToMax(map, "key", 5, "scope", validation); - - assertThat(validation.validationErrors(), hasSize(1)); - assertNotNull(parsedInt); - assertThat(parsedInt, is(5)); - assertTrue(map.isEmpty()); - } - - public void testExtractRequiredPositiveIntegerLessThanOrEqualToMax_AddsErrorForNegativeValue() { - var validation = new ValidationException(); - validation.addValidationError("previous error"); - Map map = modifiableMap(Map.of("key", -1)); - var parsedInt = extractRequiredPositiveIntegerLessThanOrEqualToMax(map, "key", 5, "scope", validation); - - assertThat(validation.validationErrors(), hasSize(2)); - assertNull(parsedInt); - assertTrue(map.isEmpty()); - assertThat(validation.validationErrors().get(1), is("[scope] Invalid value [-1]. [key] must be a positive integer")); - } - - public void testExtractRequiredPositiveIntegerLessThanOrEqualToMax_AddsErrorWhenKeyIsMissing() { - var validation = new ValidationException(); - validation.addValidationError("previous error"); - Map map = modifiableMap(Map.of("key", -1)); - var parsedInt = extractRequiredPositiveIntegerLessThanOrEqualToMax(map, "not_key", 5, "scope", validation); - - assertThat(validation.validationErrors(), hasSize(2)); - assertNull(parsedInt); - assertThat(validation.validationErrors().get(1), is("[scope] does not contain the required setting [not_key]")); - } - - public void testExtractRequiredPositiveIntegerLessThanOrEqualToMax_AddsErrorWhenValueIsGreaterThanMax() { - var validation = new ValidationException(); - validation.addValidationError("previous error"); - Map map = modifiableMap(Map.of("key", 6)); - var parsedInt = extractRequiredPositiveIntegerLessThanOrEqualToMax(map, "not_key", 5, "scope", validation); - - assertThat(validation.validationErrors(), hasSize(2)); - assertNull(parsedInt); - assertThat(validation.validationErrors().get(1), is("[scope] does not contain the required setting [not_key]")); - } - - public void testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_ReturnsValueWhenValueIsEqualToMin() { - testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_Successful(5, 5); - } - - public void testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_ReturnsValueWhenValueIsGreaterThanToMin() { - testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_Successful(5, 6); - } - - private void testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_Successful(int minValue, int actualValue) { - var validation = new ValidationException(); - validation.addValidationError("previous error"); - Map map = modifiableMap(Map.of("key", actualValue)); - var parsedInt = extractRequiredPositiveIntegerGreaterThanOrEqualToMin(map, "key", minValue, "scope", validation); - - assertThat(validation.validationErrors(), hasSize(1)); - assertNotNull(parsedInt); - assertThat(parsedInt, is(actualValue)); - assertTrue(map.isEmpty()); - } - - public void testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_AddsErrorWhenValueIsLessThanMin() { - testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_AddsError( - "key", - 5, - 4, - "[scope] Invalid value [4.0]. [key] must be a greater than or equal to [5.0]" - ); - } - - public void testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_AddsErrorWhenKeyIsMissing() { - testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_AddsError( - "not_key", - 5, - -1, - "[scope] does not contain the required setting [not_key]" - ); - } - - public void testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_AddsErrorOnNegativeValue() { - testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_AddsError( - "key", - 5, - -1, - "[scope] Invalid value [-1]. [key] must be a positive integer" - ); - } - - private void testExtractRequiredPositiveIntegerGreaterThanOrEqualToMin_AddsError( - String key, - int minValue, - int actualValue, - String error - ) { - var validation = new ValidationException(); - validation.addValidationError("previous error"); - Map map = modifiableMap(Map.of("key", actualValue)); - var parsedInt = extractRequiredPositiveIntegerGreaterThanOrEqualToMin(map, key, minValue, "scope", validation); - - assertThat(validation.validationErrors(), hasSize(2)); - assertNull(parsedInt); - assertThat(validation.validationErrors().get(1), containsString(error)); - } - public void testExtractRequiredPositiveIntegerBetween_ReturnsValueWhenValueIsBetweenMinAndMax() { var minValue = randomNonNegativeInt(); var maxValue = randomIntBetween(minValue + 2, minValue + 10); @@ -876,75 +555,6 @@ private void testExtractRequiredIntBetween_Unsuccessful(int minValue, int maxVal assertThat(validation.validationErrors().get(1), containsString("Invalid value")); } - public void testExtractOptionalEnum_ReturnsNull_WhenFieldDoesNotExist() { - var validation = new ValidationException(); - Map map = modifiableMap(Map.of("key", "value")); - var createdEnum = extractOptionalEnum(map, "abc", "scope", InputType::fromString, EnumSet.allOf(InputType.class), validation); - - assertNull(createdEnum); - assertTrue(validation.validationErrors().isEmpty()); - assertThat(map.size(), is(1)); - } - - public void testExtractOptionalEnum_ReturnsNullAndAddsException_WhenAnInvalidValueExists() { - var validation = new ValidationException(); - Map map = modifiableMap(Map.of("key", "invalid_value")); - var createdEnum = extractOptionalEnum( - map, - "key", - "scope", - InputType::fromString, - EnumSet.of(InputType.INGEST, InputType.SEARCH), - validation - ); - - assertNull(createdEnum); - assertFalse(validation.validationErrors().isEmpty()); - assertTrue(map.isEmpty()); - assertThat( - validation.validationErrors().get(0), - is("[scope] Invalid value [invalid_value] received. [key] must be one of [ingest, search]") - ); - } - - public void testExtractOptionalEnum_ReturnsNullAndAddsException_WhenValueIsNotPartOfTheAcceptableValues() { - var validation = new ValidationException(); - Map map = modifiableMap(Map.of("key", InputType.UNSPECIFIED.toString())); - var createdEnum = extractOptionalEnum(map, "key", "scope", InputType::fromString, EnumSet.of(InputType.INGEST), validation); - - assertNull(createdEnum); - assertFalse(validation.validationErrors().isEmpty()); - assertTrue(map.isEmpty()); - assertThat(validation.validationErrors().get(0), is("[scope] Invalid value [unspecified] received. [key] must be one of [ingest]")); - } - - public void testExtractOptionalEnum_ReturnsIngest_WhenValueIsAcceptable() { - var validation = new ValidationException(); - Map map = modifiableMap(Map.of("key", InputType.INGEST.toString())); - var createdEnum = extractOptionalEnum(map, "key", "scope", InputType::fromString, EnumSet.of(InputType.INGEST), validation); - - assertThat(createdEnum, is(InputType.INGEST)); - assertTrue(validation.validationErrors().isEmpty()); - assertTrue(map.isEmpty()); - } - - public void testExtractOptionalEnum_ReturnsClassification_WhenValueIsAcceptable() { - var validation = new ValidationException(); - Map map = modifiableMap(Map.of("key", InputType.CLASSIFICATION.toString())); - var createdEnum = extractOptionalEnum( - map, - "key", - "scope", - InputType::fromString, - EnumSet.of(InputType.INGEST, InputType.CLASSIFICATION), - validation - ); - - assertThat(createdEnum, is(InputType.CLASSIFICATION)); - assertTrue(validation.validationErrors().isEmpty()); - assertTrue(map.isEmpty()); - } - public void testExtractOptionalTimeValue_ReturnsNull_WhenKeyDoesNotExist() { var validation = new ValidationException(); Map map = modifiableMap(Map.of("key", 1)); diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/alibabacloudsearch/AlibabaCloudSearchServiceTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/alibabacloudsearch/AlibabaCloudSearchServiceTests.java index c9f5ea738b33b..bc3e48e98569a 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/alibabacloudsearch/AlibabaCloudSearchServiceTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/alibabacloudsearch/AlibabaCloudSearchServiceTests.java @@ -32,12 +32,12 @@ import org.elasticsearch.xcontent.ToXContent; import org.elasticsearch.xcontent.XContentType; import org.elasticsearch.xpack.core.inference.action.InferenceAction; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests; import org.elasticsearch.xpack.core.inference.results.ChunkedInferenceEmbedding; import org.elasticsearch.xpack.core.inference.results.SparseEmbeddingResults; import org.elasticsearch.xpack.core.inference.results.SparseEmbeddingResultsTests; import org.elasticsearch.xpack.core.inference.results.TextEmbeddingFloatResults; import org.elasticsearch.xpack.inference.InputTypeTests; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests; import org.elasticsearch.xpack.inference.external.action.ExecutableAction; import org.elasticsearch.xpack.inference.external.http.HttpClientManager; import org.elasticsearch.xpack.inference.external.http.sender.HttpRequestSender; @@ -64,10 +64,10 @@ import static org.elasticsearch.common.xcontent.XContentHelper.toXContent; import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertToXContentEquivalent; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.Utils.getPersistedConfigMap; import static org.elasticsearch.xpack.inference.Utils.inferenceUtilityExecutors; import static org.elasticsearch.xpack.inference.Utils.mockClusterServiceEmpty; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.services.ServiceComponentsTests.createWithEmptySettings; import static org.elasticsearch.xpack.inference.services.settings.DefaultSecretSettingsTests.getSecretSettingsMap; import static org.hamcrest.CoreMatchers.is; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/amazonbedrock/AmazonBedrockServiceTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/amazonbedrock/AmazonBedrockServiceTests.java index 04c8bca2287e5..a991697e258ce 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/amazonbedrock/AmazonBedrockServiceTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/amazonbedrock/AmazonBedrockServiceTests.java @@ -69,13 +69,13 @@ import static org.elasticsearch.common.xcontent.XContentHelper.toXContent; import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertToXContentEquivalent; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.core.inference.results.ChatCompletionResultsTests.buildExpectationCompletion; import static org.elasticsearch.xpack.core.inference.results.TextEmbeddingFloatResultsTests.buildExpectationFloat; import static org.elasticsearch.xpack.inference.Utils.getInvalidModel; import static org.elasticsearch.xpack.inference.Utils.inferenceUtilityExecutors; import static org.elasticsearch.xpack.inference.Utils.mockClusterServiceEmpty; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.common.amazon.AwsSecretSettingsTests.getAmazonBedrockSecretSettingsMap; import static org.elasticsearch.xpack.inference.services.SenderServiceTests.createMockSender; import static org.elasticsearch.xpack.inference.services.ServiceComponentsTests.createWithEmptySettings; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/azureaistudio/AzureAiStudioServiceTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/azureaistudio/AzureAiStudioServiceTests.java index 06668b91e1965..689538d1f8dc9 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/azureaistudio/AzureAiStudioServiceTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/azureaistudio/AzureAiStudioServiceTests.java @@ -75,12 +75,12 @@ import static org.elasticsearch.common.xcontent.XContentHelper.toXContent; import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertToXContentEquivalent; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.Utils.getInvalidModel; import static org.elasticsearch.xpack.inference.Utils.getPersistedConfigMap; import static org.elasticsearch.xpack.inference.Utils.inferenceUtilityExecutors; import static org.elasticsearch.xpack.inference.Utils.mockClusterServiceEmpty; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.entityAsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.getUrl; import static org.elasticsearch.xpack.inference.services.SenderServiceTests.createMockSender; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/azureopenai/AzureOpenAiServiceTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/azureopenai/AzureOpenAiServiceTests.java index b5d8fb887c62c..329ab5923c229 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/azureopenai/AzureOpenAiServiceTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/azureopenai/AzureOpenAiServiceTests.java @@ -63,13 +63,13 @@ import static org.elasticsearch.common.xcontent.XContentHelper.toXContent; import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertToXContentEquivalent; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.core.inference.results.TextEmbeddingFloatResultsTests.buildExpectationFloat; import static org.elasticsearch.xpack.inference.Utils.getInvalidModel; import static org.elasticsearch.xpack.inference.Utils.getPersistedConfigMap; import static org.elasticsearch.xpack.inference.Utils.inferenceUtilityExecutors; import static org.elasticsearch.xpack.inference.Utils.mockClusterServiceEmpty; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.entityAsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.getUrl; import static org.elasticsearch.xpack.inference.services.SenderServiceTests.createMockSender; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/cohere/CohereServiceTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/cohere/CohereServiceTests.java index 0f897500698ee..2d1d100788cd6 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/cohere/CohereServiceTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/cohere/CohereServiceTests.java @@ -69,13 +69,13 @@ import static org.elasticsearch.common.xcontent.XContentHelper.toXContent; import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertToXContentEquivalent; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.core.inference.results.TextEmbeddingFloatResultsTests.buildExpectationFloat; import static org.elasticsearch.xpack.inference.Utils.getInvalidModel; import static org.elasticsearch.xpack.inference.Utils.getPersistedConfigMap; import static org.elasticsearch.xpack.inference.Utils.inferenceUtilityExecutors; import static org.elasticsearch.xpack.inference.Utils.mockClusterServiceEmpty; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.entityAsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.getUrl; import static org.elasticsearch.xpack.inference.services.SenderServiceTests.createMockSender; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/custom/CustomServiceTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/custom/CustomServiceTests.java index 44bf17c3ac96d..17555010ecf17 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/custom/CustomServiceTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/custom/CustomServiceTests.java @@ -26,12 +26,12 @@ import org.elasticsearch.test.http.MockResponse; import org.elasticsearch.threadpool.ThreadPool; import org.elasticsearch.xpack.core.inference.action.InferenceAction; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests; import org.elasticsearch.xpack.core.inference.results.ChatCompletionResults; import org.elasticsearch.xpack.core.inference.results.ChunkedInferenceEmbedding; import org.elasticsearch.xpack.core.inference.results.RankedDocsResults; import org.elasticsearch.xpack.core.inference.results.SparseEmbeddingResults; import org.elasticsearch.xpack.core.inference.results.TextEmbeddingFloatResults; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests; import org.elasticsearch.xpack.inference.external.http.HttpClientManager; import org.elasticsearch.xpack.inference.external.http.sender.HttpRequestSenderTests; import org.elasticsearch.xpack.inference.services.AbstractInferenceServiceTests; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elastic/ElasticInferenceServiceSparseEmbeddingsModelTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elastic/ElasticInferenceServiceSparseEmbeddingsModelTests.java index 22f0121e84514..6b9c5248f0e4e 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elastic/ElasticInferenceServiceSparseEmbeddingsModelTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elastic/ElasticInferenceServiceSparseEmbeddingsModelTests.java @@ -11,7 +11,7 @@ import org.elasticsearch.inference.EmptyTaskSettings; import org.elasticsearch.inference.TaskType; import org.elasticsearch.test.ESTestCase; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.services.elastic.sparseembeddings.ElasticInferenceServiceSparseEmbeddingsModel; import org.elasticsearch.xpack.inference.services.elastic.sparseembeddings.ElasticInferenceServiceSparseEmbeddingsServiceSettings; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elastic/authorization/ElasticInferenceServiceAuthorizationHandlerTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elastic/authorization/ElasticInferenceServiceAuthorizationHandlerTests.java index e42430b6512f5..fd7bf5c4c56c4 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elastic/authorization/ElasticInferenceServiceAuthorizationHandlerTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elastic/authorization/ElasticInferenceServiceAuthorizationHandlerTests.java @@ -19,9 +19,9 @@ import org.elasticsearch.inference.TaskType; import org.elasticsearch.plugins.Plugin; import org.elasticsearch.test.ESSingleNodeTestCase; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.LocalStateInferencePlugin; import org.elasticsearch.xpack.inference.Utils; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.external.http.sender.Sender; import org.elasticsearch.xpack.inference.registry.ModelRegistry; import org.elasticsearch.xpack.inference.services.elastic.DefaultModelConfig; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elastic/densetextembeddings/ElasticInferenceServiceDenseTextEmbeddingsModelTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elastic/densetextembeddings/ElasticInferenceServiceDenseTextEmbeddingsModelTests.java index be7f056754981..d2d7a17fb985a 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elastic/densetextembeddings/ElasticInferenceServiceDenseTextEmbeddingsModelTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elastic/densetextembeddings/ElasticInferenceServiceDenseTextEmbeddingsModelTests.java @@ -11,7 +11,7 @@ import org.elasticsearch.inference.EmptyTaskSettings; import org.elasticsearch.inference.SimilarityMeasure; import org.elasticsearch.inference.TaskType; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsBuilder; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsBuilder; import org.elasticsearch.xpack.inference.services.elastic.ElasticInferenceServiceComponents; public class ElasticInferenceServiceDenseTextEmbeddingsModelTests { diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elasticsearch/ElasticsearchInternalServiceTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elasticsearch/ElasticsearchInternalServiceTests.java index 2cc0323e6d913..bbbc452ba9474 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elasticsearch/ElasticsearchInternalServiceTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elasticsearch/ElasticsearchInternalServiceTests.java @@ -51,6 +51,8 @@ import org.elasticsearch.xcontent.XContentType; import org.elasticsearch.xpack.core.action.util.QueryPage; import org.elasticsearch.xpack.core.inference.action.InferenceAction; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests; +import org.elasticsearch.xpack.core.inference.chunking.WordBoundaryChunkingSettings; import org.elasticsearch.xpack.core.inference.results.ChunkedInferenceEmbedding; import org.elasticsearch.xpack.core.inference.results.ChunkedInferenceError; import org.elasticsearch.xpack.core.inference.results.RankedDocsResults; @@ -84,9 +86,7 @@ import org.elasticsearch.xpack.inference.InferencePlugin; import org.elasticsearch.xpack.inference.InputTypeTests; import org.elasticsearch.xpack.inference.ModelConfigurationsTests; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests; import org.elasticsearch.xpack.inference.chunking.RerankRequestChunker; -import org.elasticsearch.xpack.inference.chunking.WordBoundaryChunkingSettings; import org.elasticsearch.xpack.inference.services.InferenceServiceTestCase; import org.elasticsearch.xpack.inference.services.ServiceFields; import org.hamcrest.CoreMatchers; @@ -115,10 +115,10 @@ import static org.elasticsearch.common.xcontent.XContentHelper.toXContent; import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertToXContentEquivalent; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.core.ml.action.GetTrainedModelsStatsAction.Response.RESULTS_FIELD; import static org.elasticsearch.xpack.inference.Utils.inferenceUtilityExecutors; import static org.elasticsearch.xpack.inference.Utils.mockClusterService; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.services.elasticsearch.BaseElasticsearchInternalService.notElasticsearchModelException; import static org.elasticsearch.xpack.inference.services.elasticsearch.ElasticsearchInternalService.MULTILINGUAL_E5_SMALL_MODEL_ID; import static org.elasticsearch.xpack.inference.services.elasticsearch.ElasticsearchInternalService.MULTILINGUAL_E5_SMALL_MODEL_ID_LINUX_X86; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elasticsearch/ElserInternalModelTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elasticsearch/ElserInternalModelTests.java index a0bcf4f833417..8b55cc7166944 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elasticsearch/ElserInternalModelTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elasticsearch/ElserInternalModelTests.java @@ -10,11 +10,11 @@ import org.elasticsearch.action.ActionListener; import org.elasticsearch.inference.TaskType; import org.elasticsearch.test.ESTestCase; +import org.elasticsearch.xpack.core.inference.chunking.SentenceBoundaryChunkingSettings; import org.elasticsearch.xpack.core.ml.action.CreateTrainedModelAssignmentAction; import org.elasticsearch.xpack.core.ml.inference.assignment.AssignmentStats; import org.elasticsearch.xpack.core.ml.inference.assignment.TrainedModelAssignment; import org.elasticsearch.xpack.core.ml.inference.assignment.TrainedModelAssignmentTests; -import org.elasticsearch.xpack.inference.chunking.SentenceBoundaryChunkingSettings; import static org.hamcrest.Matchers.equalTo; import static org.mockito.Mockito.mock; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elasticsearch/MultilingualE5SmallModelTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elasticsearch/MultilingualE5SmallModelTests.java index 579bf729b7175..b49288bea0b59 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elasticsearch/MultilingualE5SmallModelTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/elasticsearch/MultilingualE5SmallModelTests.java @@ -9,7 +9,7 @@ import org.elasticsearch.inference.TaskType; import org.elasticsearch.test.ESTestCase; -import org.elasticsearch.xpack.inference.chunking.SentenceBoundaryChunkingSettings; +import org.elasticsearch.xpack.core.inference.chunking.SentenceBoundaryChunkingSettings; import static org.hamcrest.Matchers.containsString; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/googleaistudio/GoogleAiStudioServiceTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/googleaistudio/GoogleAiStudioServiceTests.java index be087f73f8d5b..366b810ac6392 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/googleaistudio/GoogleAiStudioServiceTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/googleaistudio/GoogleAiStudioServiceTests.java @@ -66,13 +66,13 @@ import static org.elasticsearch.common.xcontent.XContentHelper.toXContent; import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertToXContentEquivalent; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.core.inference.results.TextEmbeddingFloatResultsTests.buildExpectationFloat; import static org.elasticsearch.xpack.inference.Utils.getInvalidModel; import static org.elasticsearch.xpack.inference.Utils.getPersistedConfigMap; import static org.elasticsearch.xpack.inference.Utils.inferenceUtilityExecutors; import static org.elasticsearch.xpack.inference.Utils.mockClusterServiceEmpty; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.entityAsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.getUrl; import static org.elasticsearch.xpack.inference.services.SenderServiceTests.createMockSender; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/googlevertexai/GoogleVertexAiServiceTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/googlevertexai/GoogleVertexAiServiceTests.java index 8724afa707914..c1ed8c6ed996b 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/googlevertexai/GoogleVertexAiServiceTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/googlevertexai/GoogleVertexAiServiceTests.java @@ -57,10 +57,10 @@ import static org.elasticsearch.common.xcontent.XContentHelper.toXContent; import static org.elasticsearch.inference.TaskType.CHAT_COMPLETION; import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertToXContentEquivalent; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.Utils.getPersistedConfigMap; import static org.elasticsearch.xpack.inference.Utils.inferenceUtilityExecutors; import static org.elasticsearch.xpack.inference.Utils.mockClusterServiceEmpty; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.services.ServiceComponentsTests.createWithEmptySettings; import static org.elasticsearch.xpack.inference.services.cohere.embeddings.CohereEmbeddingsTaskSettingsTests.getTaskSettingsMapEmpty; import static org.hamcrest.Matchers.equalTo; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/huggingface/HuggingFaceServiceTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/huggingface/HuggingFaceServiceTests.java index 67534d83a2e15..b352e2c7ce865 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/huggingface/HuggingFaceServiceTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/huggingface/HuggingFaceServiceTests.java @@ -76,12 +76,12 @@ import static org.elasticsearch.common.xcontent.XContentHelper.toXContent; import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertToXContentEquivalent; import static org.elasticsearch.xcontent.ToXContent.EMPTY_PARAMS; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.core.inference.results.TextEmbeddingFloatResultsTests.buildExpectationFloat; import static org.elasticsearch.xpack.inference.Utils.getInvalidModel; import static org.elasticsearch.xpack.inference.Utils.getPersistedConfigMap; import static org.elasticsearch.xpack.inference.Utils.inferenceUtilityExecutors; import static org.elasticsearch.xpack.inference.Utils.mockClusterServiceEmpty; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.entityAsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.getUrl; import static org.elasticsearch.xpack.inference.services.SenderServiceTests.createMockSender; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/ibmwatsonx/IbmWatsonxServiceTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/ibmwatsonx/IbmWatsonxServiceTests.java index 6e24981e3f3b3..53c1e1dac5f1f 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/ibmwatsonx/IbmWatsonxServiceTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/ibmwatsonx/IbmWatsonxServiceTests.java @@ -70,13 +70,13 @@ import static org.elasticsearch.common.xcontent.XContentHelper.toXContent; import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertToXContentEquivalent; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.core.inference.results.TextEmbeddingFloatResultsTests.buildExpectationFloat; import static org.elasticsearch.xpack.inference.Utils.getInvalidModel; import static org.elasticsearch.xpack.inference.Utils.getPersistedConfigMap; import static org.elasticsearch.xpack.inference.Utils.inferenceUtilityExecutors; import static org.elasticsearch.xpack.inference.Utils.mockClusterServiceEmpty; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.entityAsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.getUrl; import static org.elasticsearch.xpack.inference.services.SenderServiceTests.createMockSender; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/jinaai/JinaAIServiceTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/jinaai/JinaAIServiceTests.java index d408e269219cb..f3e6851871f2c 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/jinaai/JinaAIServiceTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/jinaai/JinaAIServiceTests.java @@ -65,13 +65,13 @@ import static org.elasticsearch.common.xcontent.XContentHelper.toXContent; import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertToXContentEquivalent; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.core.inference.results.TextEmbeddingFloatResultsTests.buildExpectationFloat; import static org.elasticsearch.xpack.inference.Utils.getInvalidModel; import static org.elasticsearch.xpack.inference.Utils.getPersistedConfigMap; import static org.elasticsearch.xpack.inference.Utils.inferenceUtilityExecutors; import static org.elasticsearch.xpack.inference.Utils.mockClusterServiceEmpty; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.entityAsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.getUrl; import static org.elasticsearch.xpack.inference.services.SenderServiceTests.createMockSender; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/llama/LlamaServiceTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/llama/LlamaServiceTests.java index f6a0232db529c..2da564bbb8960 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/llama/LlamaServiceTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/llama/LlamaServiceTests.java @@ -41,10 +41,10 @@ import org.elasticsearch.xcontent.XContentFactory; import org.elasticsearch.xcontent.XContentType; import org.elasticsearch.xpack.core.inference.action.InferenceAction; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests; import org.elasticsearch.xpack.core.inference.results.ChunkedInferenceEmbedding; import org.elasticsearch.xpack.core.inference.results.TextEmbeddingFloatResults; import org.elasticsearch.xpack.core.inference.results.UnifiedChatCompletionException; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests; import org.elasticsearch.xpack.inference.external.http.HttpClientManager; import org.elasticsearch.xpack.inference.external.http.sender.HttpRequestSender; import org.elasticsearch.xpack.inference.external.http.sender.HttpRequestSenderTests; @@ -82,9 +82,9 @@ import static org.elasticsearch.inference.TaskType.TEXT_EMBEDDING; import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertToXContentEquivalent; import static org.elasticsearch.xcontent.ToXContent.EMPTY_PARAMS; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.Utils.inferenceUtilityExecutors; import static org.elasticsearch.xpack.inference.Utils.mockClusterServiceEmpty; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.entityAsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.getUrl; import static org.elasticsearch.xpack.inference.services.ServiceComponentsTests.createWithEmptySettings; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/llama/embeddings/LlamaEmbeddingsModelTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/llama/embeddings/LlamaEmbeddingsModelTests.java index 4e75cab196a6d..405c38639c6d1 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/llama/embeddings/LlamaEmbeddingsModelTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/llama/embeddings/LlamaEmbeddingsModelTests.java @@ -13,7 +13,7 @@ import org.elasticsearch.test.ESTestCase; import org.elasticsearch.xpack.inference.services.settings.DefaultSecretSettings; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; public class LlamaEmbeddingsModelTests extends ESTestCase { public static LlamaEmbeddingsModel createEmbeddingsModel(String modelId, String url, String apiKey) { diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/mistral/MistralServiceTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/mistral/MistralServiceTests.java index db94ec5c9c2f5..3a53dd93fed66 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/mistral/MistralServiceTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/mistral/MistralServiceTests.java @@ -77,12 +77,12 @@ import static org.elasticsearch.common.xcontent.XContentHelper.toXContent; import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertToXContentEquivalent; import static org.elasticsearch.xcontent.ToXContent.EMPTY_PARAMS; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.Utils.getInvalidModel; import static org.elasticsearch.xpack.inference.Utils.getPersistedConfigMap; import static org.elasticsearch.xpack.inference.Utils.inferenceUtilityExecutors; import static org.elasticsearch.xpack.inference.Utils.mockClusterServiceEmpty; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.entityAsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.getUrl; import static org.elasticsearch.xpack.inference.services.SenderServiceTests.createMockSender; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/openai/OpenAiServiceTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/openai/OpenAiServiceTests.java index 0a03c7a231e8c..b386e651cc806 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/openai/OpenAiServiceTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/openai/OpenAiServiceTests.java @@ -42,10 +42,10 @@ import org.elasticsearch.xcontent.XContentFactory; import org.elasticsearch.xcontent.XContentType; import org.elasticsearch.xpack.core.inference.action.InferenceAction; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests; import org.elasticsearch.xpack.core.inference.results.ChunkedInferenceEmbedding; import org.elasticsearch.xpack.core.inference.results.TextEmbeddingFloatResults; import org.elasticsearch.xpack.core.inference.results.UnifiedChatCompletionException; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests; import org.elasticsearch.xpack.inference.external.http.HttpClientManager; import org.elasticsearch.xpack.inference.external.http.sender.HttpRequestSender; import org.elasticsearch.xpack.inference.external.http.sender.HttpRequestSenderTests; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/sagemaker/SageMakerServiceTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/sagemaker/SageMakerServiceTests.java index 5d6bec1bcfbff..0e6e2e15cdbce 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/sagemaker/SageMakerServiceTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/sagemaker/SageMakerServiceTests.java @@ -28,10 +28,10 @@ import org.elasticsearch.inference.TaskType; import org.elasticsearch.rest.RestStatus; import org.elasticsearch.threadpool.ThreadPool; +import org.elasticsearch.xpack.core.inference.chunking.WordBoundaryChunkingSettings; import org.elasticsearch.xpack.core.inference.results.ChunkedInferenceError; import org.elasticsearch.xpack.core.inference.results.TextEmbeddingFloatResultsTests; import org.elasticsearch.xpack.inference.InferencePlugin; -import org.elasticsearch.xpack.inference.chunking.WordBoundaryChunkingSettings; import org.elasticsearch.xpack.inference.common.amazon.AwsSecretSettings; import org.elasticsearch.xpack.inference.services.InferenceServiceTestCase; import org.elasticsearch.xpack.inference.services.sagemaker.model.SageMakerModel; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/validation/ElasticsearchInternalServiceModelValidatorTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/validation/ElasticsearchInternalServiceModelValidatorTests.java index 30e7a33757c16..a65d30ec8f113 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/validation/ElasticsearchInternalServiceModelValidatorTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/validation/ElasticsearchInternalServiceModelValidatorTests.java @@ -16,8 +16,8 @@ import org.elasticsearch.inference.TaskType; import org.elasticsearch.rest.RestStatus; import org.elasticsearch.test.ESTestCase; +import org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests; import org.elasticsearch.xpack.core.inference.results.TextEmbeddingResults; -import org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests; import org.elasticsearch.xpack.inference.services.elasticsearch.CustomElandEmbeddingModel; import org.elasticsearch.xpack.inference.services.elasticsearch.CustomElandInternalTextEmbeddingServiceSettings; import org.junit.Before; diff --git a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/voyageai/VoyageAIServiceTests.java b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/voyageai/VoyageAIServiceTests.java index 9bbfcb4d58667..38cc1f64f1cf3 100644 --- a/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/voyageai/VoyageAIServiceTests.java +++ b/x-pack/plugin/inference/src/test/java/org/elasticsearch/xpack/inference/services/voyageai/VoyageAIServiceTests.java @@ -63,13 +63,13 @@ import static org.elasticsearch.common.xcontent.XContentHelper.toXContent; import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertToXContentEquivalent; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; +import static org.elasticsearch.xpack.core.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.core.inference.results.TextEmbeddingFloatResultsTests.buildExpectationFloat; import static org.elasticsearch.xpack.inference.Utils.getInvalidModel; import static org.elasticsearch.xpack.inference.Utils.getPersistedConfigMap; import static org.elasticsearch.xpack.inference.Utils.inferenceUtilityExecutors; import static org.elasticsearch.xpack.inference.Utils.mockClusterServiceEmpty; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettings; -import static org.elasticsearch.xpack.inference.chunking.ChunkingSettingsTests.createRandomChunkingSettingsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.entityAsMap; import static org.elasticsearch.xpack.inference.external.http.Utils.getUrl; import static org.elasticsearch.xpack.inference.services.SenderServiceTests.createMockSender;