Update dokka to v2.1.0

CHANGELOG.md

@@ -1,22 +1,5 @@
 # TelegramBotAPI changelog
 
-## 30.0.2
-
-* `Version`:
-    * `Kotlin`: `2.2.20` -> `2.2.21`
-    * `Ktor`: `3.3.1` -> `3.3.2`
-    * `KSP`: `2.2.20-2.0.4` -> `2.3.2`
-    * `MicroUtils`: `0.26.6` -> `0.26.8`
-    * `KSLog`: `1.5.1` -> `1.5.2`
-* `Core`:
-    * Allow to use `SetWebhook` with `maxAllowedConnections` up to `100000` (fix of [#1019](https://github.com/InsanusMokrassar/ktgbotapi/issues/1019))
-* `KSP`:
-    * Fixed annotation property access for KSP2 compatibility using `withNoSuchElementWorkaround`
-    * Removed `ksp.useKSP2=false` workaround from `gradle.properties` (KSP2 is now properly supported)
-* `Utils`:
-    * Regenerated class casts extensions
-    * Allow to use custom `GetUpdates` in `longPollingFlow`
-
 ## 30.0.1
 
 * `Core`:

gradle.properties

@@ -5,5 +5,8 @@ kotlin.js.generate.externals=true
 kotlin.incremental=true
 kotlin.incremental.js=true
 
+# https://github.com/google/ksp/issues/2491
+ksp.useKSP2=false
+
 library_group=dev.inmo
-library_version=30.0.2
+library_version=30.0.1

gradle/libs.versions.toml

@@ -1,6 +1,6 @@
 [versions]
 
-kotlin = "2.2.21"
+kotlin = "2.2.20"
 kotlin-serialization = "1.9.0"
 kotlin-coroutines = "1.10.2"
 
@@ -8,18 +8,18 @@ javax-activation = "1.1.1"
 
 korlibs = "5.4.0"
 uuid = "0.8.4"
-ktor = "3.3.2"
+ktor = "3.3.1"
 
-ksp = "2.3.2"
+ksp = "2.2.20-2.0.4"
 kotlin-poet = "2.2.0"
 
-microutils = "0.26.8"
-kslog = "1.5.2"
+microutils = "0.26.6"
+kslog = "1.5.1"
 
 versions = "0.53.0"
 
 github-release-plugin = "2.5.2"
-dokka = "2.0.0"
+dokka = "2.1.0"
 
 validator = "0.18.1"
 nmcp = "1.2.0"

tgbotapi.core/api/tgbotapi.core.api

@@ -10654,7 +10654,6 @@ public final class dev/inmo/tgbotapi/types/CommonKt {
 	public static final field yShiftField Ljava/lang/String;
 	public static final field yearField Ljava/lang/String;
 	public static final fun getAllowedConnectionsLength ()Lkotlin/ranges/IntRange;
-	public static final fun getAllowedConnectionsWithLocalServerLength ()Lkotlin/ranges/IntRange;
 	public static final fun getBasketballAndFootballDiceResultLimit ()Lkotlin/ranges/IntRange;
 	public static final fun getBotCommandDescriptionLimit ()Lkotlin/ranges/IntRange;
 	public static final fun getBotCommandLengthLimit ()Lkotlin/ranges/IntRange;

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/requests/webhook/SetWebhook.kt

@@ -1,11 +1,9 @@
 package dev.inmo.tgbotapi.requests.webhook
 
-import dev.inmo.kslog.common.w
 import dev.inmo.tgbotapi.requests.abstracts.*
 import dev.inmo.tgbotapi.requests.send.media.base.DataRequest
 import dev.inmo.tgbotapi.requests.send.media.base.MultipartRequestImpl
 import dev.inmo.tgbotapi.types.*
-import dev.inmo.tgbotapi.utils.DefaultKTgBotAPIKSLog
 import kotlinx.serialization.*
 import kotlinx.serialization.builtins.serializer
 
@@ -120,22 +118,11 @@ fun SetWebhook(
 )
 
 /**
- * Represents a request for setting a webhook in Telegram's Bot API. A webhook allows Telegram to send updates directly
- * to the bot via an HTTPS POST request to the provided URL, enabling real-time interaction.
+ * Use this method to specify a url and receive incoming updates via an outgoing webhook. Whenever there is an update
+ * for the bot, we will send an HTTPS POST request to the specified url, containing a JSON-serialized Update.
  *
- * @constructor Creates a data class holding configuration options for the webhook.
- *
- * @property url The HTTPS URL to which updates will be posted. Must be valid and accessible.
- * @property certificateFile An optional path to a public certificate file for webhook verification. Use only if a self-signed certificate is applied.
- * @property ipAddress The fixed IP address for incoming webhook connections.
- * @property maxAllowedConnections The maximum number of simultaneous HTTPS connections allowed to the webhook for
- * delivering updates. You may use value outside of [allowedConnectionsLength], but be sure that it is in
- * [allowedConnectionsWithLocalServerLength] and you are using local bot api url
- * @property allowedUpdates A list of update types the bot will receive. Defaults to all update types.
- * @property dropPendingUpdates If true, all pending updates will be dropped when the webhook is changed.
- * @property secretToken An optional arbitrary secret key to ensure the webhook updates are coming from Telegram.
- *
- * @throws IllegalArgumentException if the provided maxAllowedConnections value is outside the permitted range (both [allowedConnectionsLength] and [allowedConnectionsWithLocalServerLength])
+ * If you'd like to make sure that the Webhook request comes from Telegram, we recommend using a secret path in the [url],
+ * e.g. https://www.example.com/<token>. Since nobody else knows your bot's token, you can be pretty sure it's us.
  */
 @ConsistentCopyVisibility
 @Serializable
@@ -163,19 +150,8 @@ data class SetWebhook internal constructor(
 
     init {
         maxAllowedConnections ?.let {
-            when {
-                it !in allowedConnectionsLength && it in allowedConnectionsWithLocalServerLength -> {
-                    DefaultKTgBotAPIKSLog.w {
-                        """
-                            Passed amount of allowed connections to server is $it and it exceeds default amount of
-                            connections $allowedConnectionsLength, but can be used with local bot api server. Make sure
-                            you are using local bot api url in your bot.
-                        """.trimIndent()
-                    }
-                }
-                it !in allowedConnectionsLength -> {
-                    throw IllegalArgumentException("Allowed connection for webhook must be in $allowedConnectionsLength range (but passed $it)")
-                }
+            if (it !in allowedConnectionsLength) {
+                throw IllegalArgumentException("Allowed connection for webhook must be in $allowedConnectionsLength range (but passed $it)")
             }
         }
     }

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/Common.kt

@@ -64,7 +64,6 @@ val threadNameLength = 1 until 128
 val chatDescriptionLength = 0 until 256
 val inlineResultQueryIdLingth = 1 until 64
 val allowedConnectionsLength = 1 .. 100
-val allowedConnectionsWithLocalServerLength = 1 .. 100000
 
 val invoiceTitleLimit = 1 until 32
 val invoiceDescriptionLimit = 1 until 256

tgbotapi.ksp/src/main/kotlin/TelegramBotAPISymbolProcessor.kt

@@ -8,7 +8,6 @@ import com.squareup.kotlinpoet.FileSpec
 import com.squareup.kotlinpoet.asClassName
 import com.squareup.kotlinpoet.ksp.writeTo
 import dev.inmo.micro_ksp.generator.resolveSubclasses
-import dev.inmo.micro_ksp.generator.withNoSuchElementWorkaround
 import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.ChatEvent
 import dev.inmo.tgbotapi.utils.RiskFeature
 import dev.inmo.tgbotapi.utils.internal.ClassCastsExcluded
@@ -31,9 +30,7 @@ class TelegramBotAPISymbolProcessor(
         val classes = resolver.getSymbolsWithAnnotation(classCastsIncludedClassName.canonicalName).filterIsInstance<KSClassDeclaration>()
         val classesRegexes: Map<KSClassDeclaration, Pair<Regex?, Regex?>> = classes.mapNotNull {
             it to (it.getAnnotationsByType(ClassCastsIncluded::class).firstNotNullOfOrNull {
-                val typesRegex = withNoSuchElementWorkaround("") { it.typesRegex }
-                val excludeRegex = withNoSuchElementWorkaround("") { it.excludeRegex }
-                typesRegex.takeIf { it.isNotEmpty() } ?.let(::Regex) to excludeRegex.takeIf { it.isNotEmpty() } ?.let(::Regex)
+                it.typesRegex.takeIf { it.isNotEmpty() } ?.let(::Regex) to it.excludeRegex.takeIf { it.isNotEmpty() } ?.let(::Regex)
             } ?: return@mapNotNull null)
         }.toMap()
         val classesSubtypes = mutableMapOf<KSClassDeclaration, MutableSet<KSClassDeclaration>>()

tgbotapi.utils/api/tgbotapi.utils.api

@@ -3705,9 +3705,7 @@ public final class dev/inmo/tgbotapi/extensions/utils/updates/retrieving/LongPol
 	public static synthetic fun longPolling$default (Ldev/inmo/tgbotapi/bot/RequestsExecutor;ILkotlinx/coroutines/CoroutineScope;Lkotlin/jvm/functions/Function2;IZZLjava/lang/Long;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lkotlinx/coroutines/Job;
 	public static synthetic fun longPolling$default (Ldev/inmo/tgbotapi/bot/RequestsExecutor;Ldev/inmo/tgbotapi/updateshandlers/UpdatesFilter;ILkotlinx/coroutines/CoroutineScope;ZZLjava/lang/Long;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lkotlinx/coroutines/Job;
 	public static final fun longPollingFlow (Ldev/inmo/tgbotapi/bot/RequestsExecutor;ILkotlin/jvm/functions/Function2;Ljava/util/List;ZZLjava/lang/Long;)Lkotlinx/coroutines/flow/Flow;
-	public static final fun longPollingFlow (Ldev/inmo/tgbotapi/bot/RequestsExecutor;Lkotlin/jvm/functions/Function2;ZZLjava/lang/Long;Lkotlin/jvm/functions/Function1;)Lkotlinx/coroutines/flow/Flow;
 	public static synthetic fun longPollingFlow$default (Ldev/inmo/tgbotapi/bot/RequestsExecutor;ILkotlin/jvm/functions/Function2;Ljava/util/List;ZZLjava/lang/Long;ILjava/lang/Object;)Lkotlinx/coroutines/flow/Flow;
-	public static synthetic fun longPollingFlow$default (Ldev/inmo/tgbotapi/bot/RequestsExecutor;Lkotlin/jvm/functions/Function2;ZZLjava/lang/Long;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lkotlinx/coroutines/flow/Flow;
 	public static final fun retrieveAccumulatedUpdates (Ldev/inmo/tgbotapi/bot/RequestsExecutor;Ldev/inmo/tgbotapi/updateshandlers/FlowsUpdatesFilter;ZZLkotlinx/coroutines/CoroutineScope;ZLjava/lang/Long;Lkotlin/jvm/functions/Function2;)Lkotlinx/coroutines/Job;
 	public static final fun retrieveAccumulatedUpdates (Ldev/inmo/tgbotapi/bot/RequestsExecutor;ZZLkotlinx/coroutines/CoroutineScope;Lkotlin/jvm/functions/Function2;Ljava/util/List;ZLjava/lang/Long;Lkotlin/jvm/functions/Function2;)Lkotlinx/coroutines/Job;
 	public static synthetic fun retrieveAccumulatedUpdates$default (Ldev/inmo/tgbotapi/bot/RequestsExecutor;Ldev/inmo/tgbotapi/updateshandlers/FlowsUpdatesFilter;ZZLkotlinx/coroutines/CoroutineScope;ZLjava/lang/Long;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lkotlinx/coroutines/Job;

tgbotapi.utils/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/utils/updates/retrieving/LongPolling.kt

@@ -1,5 +1,6 @@
 package dev.inmo.tgbotapi.extensions.utils.updates.retrieving
 
+import dev.inmo.kslog.common.logger
 import dev.inmo.micro_utils.coroutines.*
 import dev.inmo.tgbotapi.bot.RequestsExecutor
 import dev.inmo.tgbotapi.bot.TelegramBot
@@ -14,36 +15,30 @@ import dev.inmo.tgbotapi.types.update.*
 import dev.inmo.tgbotapi.types.update.abstracts.BaseSentMessageUpdate
 import dev.inmo.tgbotapi.types.update.abstracts.Update
 import dev.inmo.tgbotapi.updateshandlers.*
+import dev.inmo.tgbotapi.utils.DefaultKTgBotAPIKSLog
+import dev.inmo.tgbotapi.utils.causedCancellationException
+import dev.inmo.tgbotapi.utils.isCausedByCancellation
 import dev.inmo.tgbotapi.utils.isCausedUnresolvedAddressException
 import dev.inmo.tgbotapi.utils.subscribeWithBotLogger
 import io.ktor.client.network.sockets.ConnectTimeoutException
 import io.ktor.client.plugins.HttpRequestTimeoutException
+import io.ktor.util.network.UnresolvedAddressException
 import io.ktor.utils.io.CancellationException
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
 
 /**
- * Starts a long polling flow to receive updates continuously from the Telegram Bot API.
- *
- * This method retrieves updates from the bot, processes them, and emits them as a flow of `Update` objects.
- * It allows handling of updates with features like automatic webhook disabling, timeout exception skipping,
- * and media group handling with debounce time.
- *
- * @param exceptionsHandler Optional exception handler to manage exceptions that occur during the polling process.
- * @param autoDisableWebhooks Specifies whether to automatically disable existing webhooks before starting the long polling flow (default: `true`).
- * @param autoSkipTimeoutExceptions Defines if timeout-related exceptions should automatically be skipped during the polling (default: `true`).
- * @param mediaGroupsDebounceTimeMillis The debounce time in milliseconds for processing media group updates.
- *        If set to `null`, media group handling is disabled (default: `1000L`).
- * @param getUpdatesRequestCreator A function that creates a `GetUpdates` request for retrieving updates.
- *        This function accepts the identifier of the most recent update as an input and returns the new request.
- * @return A [Flow] of [Update] objects that represents the continuous stream of updates received.
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
  */
 fun TelegramBot.longPollingFlow(
+    timeoutSeconds: Seconds = 30,
     exceptionsHandler: (ExceptionHandler<Unit>)? = null,
+    allowedUpdates: List<String>? = ALL_UPDATES_LIST,
     autoDisableWebhooks: Boolean = true,
     autoSkipTimeoutExceptions: Boolean = true,
     mediaGroupsDebounceTimeMillis: Long? = 1000L,
-    getUpdatesRequestCreator: (sinceUpdate: UpdateId?) -> GetUpdates
 ): Flow<Update> = channelFlow {
     if (autoDisableWebhooks) {
         runCatchingLogging(logger = Log) {
@@ -124,7 +119,11 @@ fun TelegramBot.longPollingFlow(
         while (isActive) {
             runCatchingLogging(logger = Log) {
                 execute(
-                    getUpdatesRequestCreator(lastUpdateIdentifier ?.plus(1))
+                    GetUpdates(
+                        offset = lastUpdateIdentifier?.plus(1),
+                        timeout = timeoutSeconds,
+                        allowed_updates = allowedUpdates
+                    )
                 ).let { originalUpdates ->
                     updatesHandler(originalUpdates)
                 }
@@ -149,45 +148,6 @@ fun TelegramBot.longPollingFlow(
     }
 }
 
-/**
- * Initiates a long polling flow for receiving updates continuously from the Telegram Bot API.
- * This method provides a customized way to handle the retrieval of updates with options
- * to configure timeouts, update types, exception handling, and media group processing.
- *
- * @param timeoutSeconds The maximum time in seconds for the server to wait for available updates
- * before responding (default: `30`).
- * @param exceptionsHandler An optional exception handler for managing exceptions that occur during the
- * long polling process. If not provided, exceptions will pass through unhandled.
- * @param allowedUpdates A list of the update types to retrieve. By default, retrieves all possible
- * update types as defined in `ALL_UPDATES_LIST`.
- * @param autoDisableWebhooks Whether the current webhook should be disabled automatically before starting the
- * long polling flow (default: `true`).
- * @param autoSkipTimeoutExceptions Determines if timeout-related exceptions should be automatically skipped
- * during the polling process (default: `true`).
- * @param mediaGroupsDebounceTimeMillis The debounce time in milliseconds for processing updates containing
- * media groups. If set to `null`, media group handling is disabled (default: `1000L`).
- * @return A Flow that emits Update objects representing the updates fetched from the Telegram Bot API.
- */
-fun TelegramBot.longPollingFlow(
-    timeoutSeconds: Seconds = 30,
-    exceptionsHandler: (ExceptionHandler<Unit>)? = null,
-    allowedUpdates: List<String>? = ALL_UPDATES_LIST,
-    autoDisableWebhooks: Boolean = true,
-    autoSkipTimeoutExceptions: Boolean = true,
-    mediaGroupsDebounceTimeMillis: Long? = 1000L,
-): Flow<Update> = longPollingFlow(
-    exceptionsHandler = exceptionsHandler,
-    autoDisableWebhooks = autoDisableWebhooks,
-    autoSkipTimeoutExceptions = autoSkipTimeoutExceptions,
-    mediaGroupsDebounceTimeMillis = mediaGroupsDebounceTimeMillis,
-) {
-    GetUpdates(
-        offset = it,
-        timeout = timeoutSeconds,
-        allowed_updates = allowedUpdates
-    )
-}
-
 /**
  * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
  * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be