Update greetings.yml

This reverts commit b7c3f9f607.

.github/workflows/greetings.yml

@@ -5,6 +5,9 @@ on: [pull_request, issues]
 jobs:
   greeting:
     runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
     steps:
     - uses: actions/first-interaction@v1
       with:

.github/workflows/kdocs.yml

@@ -10,7 +10,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-java@v1
         with:
-          java-version: 11
+          java-version: 17
       - name: Build
         run: ./gradlew dokkaHtmlMultiModule
       - name: Publish KDocs

.github/workflows/packages_publishing.yml

@@ -7,9 +7,9 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-java@v1
         with:
-          java-version: 11
+          java-version: 17
       - name: Setup LibCurl
-        run: sudo apt install -y libcurl4-openssl-dev
+        run: sudo apt update && sudo apt install -y libcurl4-openssl-dev
       - name: Rewrite version
         run: |
           branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"

CHANGELOG.md

@@ -1,5 +1,31 @@
 # TelegramBotAPI changelog
 
+## 9.4.0
+
+* `Version`:
+  * `Kotlin`: `1.9.20` -> `1.9.21`
+  * `Serialization`: `1.6.0` -> `1.6.1`
+  * `Ktor`: `2.3.5` -> `2.3.6`
+  * `MicroUtils`: `0.20.12` -> `0.20.15`
+
+## 9.3.0
+
+This release become possible thanks to [Anton Lakotka](https://youtrack.jetbrains.com/users/anton.lakotka)
+
+**THIS RELEASE CONTAINS UPDATES UP TO RELEASE CANDIDATES VERSIONS**
+
+**UPDATE MAY HAVE BREAKING CHANGES**
+
+**SINCE THIS UPDATE IT WILL BE REQUIRED TO USE JDK 17+ FOR DEVELOPMENT**
+
+* `Version`:
+  * `Kotlin`: `1.8.22` -> `1.9.20`
+  * `Serialization`: `1.5.1` -> `1.6.0`
+  * `KorLibs`: `4.0.3` -> `4.0.10`
+  * `UUID`: `0.7.1` -> `0.8.1`
+  * `Ktor`: `2.3.4` -> `2.3.5`
+  * `MicroUtils`: `0.19.9` -> `0.20.12`
+
 ## 9.2.4
 
 * `Utils`:

build.gradle

@@ -16,6 +16,7 @@ buildscript {
 
 plugins {
     alias(libs.plugins.kotlin.dokka)
+    alias(libs.plugins.versions)
 }
 
 // temporal crutch until legacy tests will be stabled or legacy target will be removed

gradle.properties

@@ -6,4 +6,4 @@ kotlin.incremental=true
 kotlin.incremental.js=true
 
 library_group=dev.inmo
-library_version=9.2.4
+library_version=9.4.0

gradle/libs.versions.toml

@@ -1,22 +1,25 @@
 [versions]
 
-kotlin = "1.8.22"
+kotlin = "1.9.21"
-kotlin-serialization = "1.5.1"
+kotlin-serialization = "1.6.1"
 kotlin-coroutines = "1.7.3"
 
 javax-activation = "1.1.1"
 
-korlibs = "4.0.3"
+korlibs = "4.0.10"
-uuid = "0.7.1"
+uuid = "0.8.1"
-ktor = "2.3.4"
+ktor = "2.3.6"
 
-ksp = "1.8.22-1.0.11"
+ksp = "1.9.20-1.0.14"
-kotlin-poet = "1.14.2"
+kotlin-poet = "1.15.1"
 
-microutils = "0.19.9"
+microutils = "0.20.15"
+kslog = "1.3.1"
+
+versions = "0.50.0"
 
 github-release-plugin = "2.4.1"
-dokka = "1.8.20"
+dokka = "1.9.10"
 
 [libraries]
 
@@ -52,6 +55,8 @@ microutils-languageCodes = { module = "dev.inmo:micro_utils.language_codes", ver
 microutils-ktor-common = { module = "dev.inmo:micro_utils.ktor.common", version.ref = "microutils" }
 microutils-fsm-common = { module = "dev.inmo:micro_utils.fsm.common", version.ref = "microutils" }
 
+kslog = { module = "dev.inmo:kslog", version.ref = "kslog" }
+
 # ksp dependencies
 
 kotlin-poet = { module = "com.squareup:kotlinpoet-ksp", version.ref = "kotlin-poet" }
@@ -71,3 +76,4 @@ kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
 kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
 kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
 kotlin-dokka = { id = "org.jetbrains.dokka", version.ref = "dokka" }
+versions = { id = "com.github.ben-manes.versions", version.ref = "versions" }

gradle/wrapper/gradle-wrapper.properties

@@ -2,4 +2,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.6.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip

mppProjectWithSerialization.gradle

@@ -5,7 +5,7 @@ kotlin {
     jvm {
         compilations.main {
             kotlinOptions {
-                jvmTarget = "1.8"
+                jvmTarget = "17"
             }
         }
     }
@@ -15,6 +15,7 @@ kotlin {
     }
     linuxX64()
     mingwX64()
+    linuxArm64()
 
     sourceSets {
         commonMain {
@@ -40,10 +41,18 @@ kotlin {
                 implementation libs.kotlin.test.junit
             }
         }
+        all {
+            languageSettings {
+                optIn('dev.inmo.tgbotapi.utils.RiskFeature')
+                optIn('dev.inmo.tgbotapi.utils.PreviewFeature')
+                optIn('dev.inmo.micro_utils.common.Warning')
+                optIn('dev.inmo.micro_utils.common.PreviewFeature')
+            }
+        }
     }
 }
 
 java {
-    sourceCompatibility = JavaVersion.VERSION_1_8
+    sourceCompatibility = JavaVersion.VERSION_17
-    targetCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_17
 }

publish.gradle

@@ -1,8 +1,7 @@
 apply plugin: 'maven-publish'
 
 task javadocsJar(type: Jar) {
-    archiveClassifier.convention("javadoc")
+    archiveClassifier = 'javadoc'
-    archiveClassifier.set("javadoc")
 }
 
 publishing {
@@ -97,4 +96,27 @@ if (project.hasProperty("signing.gnupg.keyName")) {
             dependsOn(it)
         }
     }
+
+    // Workaround to make android sign operations depend on signing tasks
+    project.getTasks().withType(AbstractPublishToMaven.class).configureEach {
+        def signingTasks = project.getTasks().withType(Sign.class)
+        mustRunAfter(signingTasks)
+    }
+    // Workaround to make test tasks use sign
+    project.getTasks().withType(Sign.class).configureEach { signTask ->
+        def withoutSign = (signTask.name.startsWith("sign") ? signTask.name.minus("sign") : signTask.name)
+        def pubName = withoutSign.endsWith("Publication") ? withoutSign.substring(0, withoutSign.length() - "Publication".length()) : withoutSign
+        // These tasks only exist for native targets, hence findByName() to avoid trying to find them for other targets
+
+        // Task ':linkDebugTest<platform>' uses this output of task ':sign<platform>Publication' without declaring an explicit or implicit dependency
+        def debugTestTask = tasks.findByName("linkDebugTest$pubName")
+        if (debugTestTask != null) {
+            signTask.mustRunAfter(debugTestTask)
+        }
+        // Task ':compileTestKotlin<platform>' uses this output of task ':sign<platform>Publication' without declaring an explicit or implicit dependency
+        def testTask = tasks.findByName("compileTestKotlin$pubName")
+        if (testTask != null) {
+            signTask.mustRunAfter(testTask)
+        }
+    }
 }

tgbotapi.behaviour_builder.fsm/build.gradle

@@ -13,6 +13,8 @@ kotlin {
     sourceSets {
         commonMain {
             dependencies {
+                api project(":tgbotapi.core")
+                api project(":tgbotapi.utils")
                 api project(":tgbotapi.behaviour_builder")
                 api libs.microutils.fsm.common
             }

tgbotapi.behaviour_builder/build.gradle

@@ -13,7 +13,8 @@ kotlin {
     sourceSets {
         commonMain {
             dependencies {
-                api project(":tgbotapi.utils")
+                api project(path: ':tgbotapi.core')
+                api project(path: ':tgbotapi.utils')
             }
         }
     }

tgbotapi.behaviour_builder/src/linuxArm64Main/kotlin/ActualDefaultCoroutineScopeProvider.kt

@@ -0,0 +1,6 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+
+actual var defaultCoroutineScopeProvider: () -> CoroutineScope = { CoroutineScope(Dispatchers.Default) }

tgbotapi.core/build.gradle

@@ -31,6 +31,8 @@ kotlin {
                 api libs.microutils.languageCodes
 
                 api libs.ktor.client.core
+
+                api libs.kslog
             }
         }
         commonTest {
@@ -55,6 +57,12 @@ kotlin {
             }
         }
 
+        linuxArm64Main {
+            dependencies {
+                api libs.ktor.client.cio
+            }
+        }
+
         mingwX64Main {
             dependencies {
                 api libs.ktor.client.winhttp

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/bot/ktor/KtorRequestsExecutor.kt

@@ -1,8 +1,10 @@
 package dev.inmo.tgbotapi.bot.ktor
 
+import dev.inmo.kslog.common.KSLog
 import dev.inmo.tgbotapi.bot.BaseRequestsExecutor
 import dev.inmo.tgbotapi.bot.settings.limiters.ExceptionsOnlyLimiter
 import dev.inmo.tgbotapi.bot.settings.limiters.RequestLimiter
+import dev.inmo.tgbotapi.utils.DefaultKTgBotAPIKSLog
 import dev.inmo.tgbotapi.utils.TelegramAPIUrlsKeeper
 import dev.inmo.tgbotapi.utils.nonstrictJsonFormat
 import io.ktor.client.*
@@ -14,12 +16,35 @@ import kotlinx.serialization.json.Json
  * * On JS, JVM and MingwX64 platforms it is [dev.inmo.tgbotapi.bot.ktor.base.DefaultKtorRequestsExecutor]
  * * On LinuxX64 it is [dev.inmo.tgbotapi.bot.ktor.base.MultipleClientKtorRequestsExecutor]
  */
-expect class KtorRequestsExecutor (
+expect class KtorRequestsExecutor internal constructor(
+    telegramAPIUrlsKeeper: TelegramAPIUrlsKeeper,
+    client: HttpClient,
+    callsFactories: List<KtorCallFactory>,
+    excludeDefaultFactories: Boolean,
+    requestsLimiter: RequestLimiter,
+    jsonFormatter: Json,
+    pipelineStepsHolder: KtorPipelineStepsHolder,
+    logger: KSLog,
+    diff: Unit // just a diff property to know where constructor and where calling function with defaults
+) : BaseRequestsExecutor
+
+fun KtorRequestsExecutor(
     telegramAPIUrlsKeeper: TelegramAPIUrlsKeeper,
     client: HttpClient = HttpClient(),
     callsFactories: List<KtorCallFactory> = emptyList(),
     excludeDefaultFactories: Boolean = false,
     requestsLimiter: RequestLimiter = ExceptionsOnlyLimiter,
     jsonFormatter: Json = nonstrictJsonFormat,
-    pipelineStepsHolder: KtorPipelineStepsHolder = KtorPipelineStepsHolder
+    pipelineStepsHolder: KtorPipelineStepsHolder = KtorPipelineStepsHolder,
-) : BaseRequestsExecutor
+    logger: KSLog = DefaultKTgBotAPIKSLog,
+) = KtorRequestsExecutor(
+    telegramAPIUrlsKeeper = telegramAPIUrlsKeeper,
+    client = client,
+    callsFactories = callsFactories,
+    excludeDefaultFactories = excludeDefaultFactories,
+    requestsLimiter = requestsLimiter,
+    jsonFormatter = jsonFormatter,
+    pipelineStepsHolder = pipelineStepsHolder,
+    logger = logger,
+    diff = kotlin.Unit,
+)

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/bot/ktor/KtorRequestsExecutorFactories.kt

@@ -1,5 +1,6 @@
 package dev.inmo.tgbotapi.bot.ktor
 
+import dev.inmo.kslog.common.KSLog
 import dev.inmo.tgbotapi.bot.BaseRequestsExecutor
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.bot.ktor.base.*
@@ -10,9 +11,9 @@ import io.ktor.client.HttpClient
 import kotlinx.serialization.json.Json
 
 @RiskFeature
-fun createTelegramBotDefaultKtorCallRequestsFactories() = listOf(
+fun createTelegramBotDefaultKtorCallRequestsFactories(logger: KSLog? = null) = listOf(
-    SimpleRequestCallFactory(),
+    SimpleRequestCallFactory(logger),
-    MultipartRequestCallFactory(),
+    MultipartRequestCallFactory(logger),
     DownloadFileRequestCallFactory,
     DownloadFileChannelRequestCallFactory
 )
@@ -25,6 +26,8 @@ class KtorRequestsExecutorBuilder(
     var excludeDefaultFactories: Boolean = false
     var requestsLimiter: RequestLimiter = ExceptionsOnlyLimiter
     var jsonFormatter: Json = nonstrictJsonFormat
+    var logger: KSLog = DefaultKTgBotAPIKSLog
+    var pipelineStepsHolder: KtorPipelineStepsHolder = KtorPipelineStepsHolder
 
     fun build() = KtorRequestsExecutor(
         telegramAPIUrlsKeeper,
@@ -32,7 +35,9 @@ class KtorRequestsExecutorBuilder(
         callsFactories,
         excludeDefaultFactories,
         requestsLimiter,
-        jsonFormatter
+        jsonFormatter,
+        pipelineStepsHolder,
+        logger
     )
 }
 

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/bot/ktor/base/AbstractRequestCallFactory.kt

@@ -1,23 +1,30 @@
 package dev.inmo.tgbotapi.bot.ktor.base
 
+import dev.inmo.kslog.common.KSLog
+import dev.inmo.kslog.common.v
+import dev.inmo.kslog.common.w
 import dev.inmo.micro_utils.coroutines.runCatchingSafely
 import dev.inmo.tgbotapi.bot.ktor.KtorCallFactory
 import dev.inmo.tgbotapi.bot.exceptions.newRequestException
 import dev.inmo.tgbotapi.requests.GetUpdatesRequest
 import dev.inmo.tgbotapi.requests.abstracts.Request
 import dev.inmo.tgbotapi.types.Response
+import dev.inmo.tgbotapi.utils.DefaultKTgBotAPIKSLog
 import dev.inmo.tgbotapi.utils.TelegramAPIUrlsKeeper
 import io.ktor.client.HttpClient
 import io.ktor.client.plugins.timeout
 import io.ktor.client.request.*
 import io.ktor.client.statement.bodyAsText
 import io.ktor.http.ContentType
+import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
 import kotlin.collections.set
 
 var defaultUpdateTimeoutForZeroDelay = 1000L
 
-abstract class AbstractRequestCallFactory : KtorCallFactory {
+abstract class AbstractRequestCallFactory(
+    protected open val logger: KSLog = DefaultKTgBotAPIKSLog
+) : KtorCallFactory {
     private val methodsCache: MutableMap<String, String> = mutableMapOf()
     override suspend fun <T : Any> makeCall(
         client: HttpClient,
@@ -26,6 +33,7 @@ abstract class AbstractRequestCallFactory : KtorCallFactory {
         jsonFormatter: Json
     ): T? {
         val preparedBody = prepareCallBody(client, urlsKeeper, request) ?: return null
+        logger.v { "Prepared body for $request: $preparedBody" }
 
         client.post {
             url(
@@ -54,7 +62,9 @@ abstract class AbstractRequestCallFactory : KtorCallFactory {
             setBody(preparedBody)
         }.let { response ->
             val content = response.bodyAsText()
+            logger.v { "Raw answer for $request: $content" }
             val responseObject = jsonFormatter.decodeFromString(Response.serializer(), content)
+            logger.v { "Answer as json for $request: $responseObject" }
 
             return runCatchingSafely {
                 (responseObject.result?.let {
@@ -66,6 +76,8 @@ abstract class AbstractRequestCallFactory : KtorCallFactory {
                         "Can't get result object from $content"
                     )
                 })
+            }.onFailure {
+                logger.w { "Got exception answer for $request: $it" }
             }.getOrThrow()
         }
     }

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/bot/ktor/base/DefaultKtorRequestsExecutor.kt

@@ -1,5 +1,9 @@
 package dev.inmo.tgbotapi.bot.ktor.base
 
+import dev.inmo.kslog.common.KSLog
+import dev.inmo.kslog.common.e
+import dev.inmo.kslog.common.i
+import dev.inmo.kslog.common.v
 import dev.inmo.micro_utils.coroutines.runCatchingSafely
 import dev.inmo.tgbotapi.bot.BaseRequestsExecutor
 import dev.inmo.tgbotapi.bot.exceptions.BotException
@@ -7,6 +11,7 @@ import dev.inmo.tgbotapi.bot.exceptions.CommonBotException
 import dev.inmo.tgbotapi.bot.exceptions.newRequestException
 import dev.inmo.tgbotapi.bot.ktor.KtorCallFactory
 import dev.inmo.tgbotapi.bot.ktor.KtorPipelineStepsHolder
+import dev.inmo.tgbotapi.bot.ktor.KtorRequestsExecutor
 import dev.inmo.tgbotapi.bot.ktor.createTelegramBotDefaultKtorCallRequestsFactories
 import dev.inmo.tgbotapi.bot.settings.limiters.ExceptionsOnlyLimiter
 import dev.inmo.tgbotapi.bot.settings.limiters.RequestLimiter
@@ -19,19 +24,23 @@ import io.ktor.client.plugins.*
 import io.ktor.client.statement.*
 import kotlinx.serialization.json.Json
 
-class DefaultKtorRequestsExecutor(
+class DefaultKtorRequestsExecutor internal constructor(
     telegramAPIUrlsKeeper: TelegramAPIUrlsKeeper,
-    client: HttpClient = HttpClient(),
+    client: HttpClient,
-    callsFactories: List<KtorCallFactory> = emptyList(),
+    callsFactories: List<KtorCallFactory>,
-    excludeDefaultFactories: Boolean = false,
+    excludeDefaultFactories: Boolean,
-    private val requestsLimiter: RequestLimiter = ExceptionsOnlyLimiter,
+    private val requestsLimiter: RequestLimiter,
-    private val jsonFormatter: Json = nonstrictJsonFormat,
+    private val jsonFormatter: Json,
-    private val pipelineStepsHolder: KtorPipelineStepsHolder = KtorPipelineStepsHolder
+    private val pipelineStepsHolder: KtorPipelineStepsHolder,
+    private val logger: KSLog,
+    diff: Unit
 ) : BaseRequestsExecutor(telegramAPIUrlsKeeper) {
     private val callsFactories: List<KtorCallFactory> = callsFactories.run {
         if (!excludeDefaultFactories) {
-            this + createTelegramBotDefaultKtorCallRequestsFactories()
+            logger.v { "Installing default factories" }
+            this + createTelegramBotDefaultKtorCallRequestsFactories(logger)
         } else {
+            logger.v { "Default factories will not be installed" }
             this
         }
     }
@@ -44,19 +53,23 @@ class DefaultKtorRequestsExecutor(
 
     override suspend fun <T : Any> execute(request: Request<T>): T {
         return runCatchingSafely {
+            logger.v { "Start request $request" }
             pipelineStepsHolder.onBeforeSearchCallFactory(request, callsFactories)
             requestsLimiter.limit(request) {
                 var result: T? = null
                 lateinit var factoryHandledRequest: KtorCallFactory
                 for (potentialFactory in callsFactories) {
                     pipelineStepsHolder.onBeforeCallFactoryMakeCall(request, potentialFactory)
-                    result = potentialFactory.makeCall(
+                    logger.v { "Trying factory $potentialFactory for $request" }
+                    val resultFromFactory = potentialFactory.makeCall(
                         client,
                         telegramAPIUrlsKeeper,
                         request,
                         jsonFormatter
                     )
-                    result = pipelineStepsHolder.onAfterCallFactoryMakeCall(result, request, potentialFactory)
+                    logger.v { "Result of factory $potentialFactory handling $request: $resultFromFactory" }
+                    result = pipelineStepsHolder.onAfterCallFactoryMakeCall(resultFromFactory, request, potentialFactory)
+                    logger.v { "Result of pipeline $pipelineStepsHolder handling $resultFromFactory: $result" }
                     if (result != null) {
                         factoryHandledRequest = potentialFactory
                         break
@@ -69,6 +82,7 @@ class DefaultKtorRequestsExecutor(
             }
         }.let {
             val result = it.exceptionOrNull() ?.let { e ->
+                logger.v(e) { "Got exception on handling of $request" }
                 pipelineStepsHolder.onRequestException(request, e) ?.let { return@let it }
 
                 when (e) {
@@ -88,9 +102,13 @@ class DefaultKtorRequestsExecutor(
                     }
                     is BotException -> e
                     else -> CommonBotException(cause = e)
+                }.also {
+                    logger.v(e) { "Result exception on handling of $request: $it" }
                 }
             } ?.let { Result.failure(it) } ?: it
-            pipelineStepsHolder.onRequestReturnResult(result, request, callsFactories)
+            pipelineStepsHolder.onRequestReturnResult(result, request, callsFactories).also {
+                logger.v { "Result of handling $request: $it" }
+            }
         }
     }
 

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/bot/ktor/base/DownloadFileChannelRequestCallFactory.kt

@@ -5,6 +5,7 @@ import dev.inmo.tgbotapi.bot.ktor.KtorCallFactory
 import dev.inmo.tgbotapi.requests.DownloadFileStream
 import dev.inmo.tgbotapi.requests.abstracts.Request
 import dev.inmo.tgbotapi.utils.ByteReadChannelAllocator
+import dev.inmo.tgbotapi.utils.RiskFeature
 import dev.inmo.tgbotapi.utils.TelegramAPIUrlsKeeper
 import io.ktor.client.HttpClient
 import io.ktor.client.call.receive
@@ -15,6 +16,7 @@ import io.ktor.utils.io.*
 import kotlinx.coroutines.*
 import kotlinx.serialization.json.Json
 
+@RiskFeature
 object DownloadFileChannelRequestCallFactory : KtorCallFactory {
     override suspend fun <T : Any> makeCall(
         client: HttpClient,

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/bot/ktor/base/DownloadFileRequestCallFactory.kt

@@ -4,12 +4,14 @@ import dev.inmo.micro_utils.coroutines.safely
 import dev.inmo.tgbotapi.bot.ktor.KtorCallFactory
 import dev.inmo.tgbotapi.requests.DownloadFile
 import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.utils.RiskFeature
 import dev.inmo.tgbotapi.utils.TelegramAPIUrlsKeeper
 import io.ktor.client.HttpClient
 import io.ktor.client.request.get
 import io.ktor.client.statement.readBytes
 import kotlinx.serialization.json.Json
 
+@RiskFeature
 object DownloadFileRequestCallFactory : KtorCallFactory {
     override suspend fun <T : Any> makeCall(
         client: HttpClient,

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/bot/ktor/base/MultipartRequestCallFactory.kt

@@ -1,6 +1,8 @@
 package dev.inmo.tgbotapi.bot.ktor.base
 
+import dev.inmo.kslog.common.KSLog
 import dev.inmo.tgbotapi.requests.abstracts.*
+import dev.inmo.tgbotapi.utils.DefaultKTgBotAPIKSLog
 import dev.inmo.tgbotapi.utils.TelegramAPIUrlsKeeper
 import dev.inmo.tgbotapi.utils.mapWithCommonValues
 import io.ktor.client.HttpClient
@@ -8,7 +10,7 @@ import io.ktor.client.request.forms.*
 import io.ktor.http.Headers
 import io.ktor.http.HttpHeaders
 
-class MultipartRequestCallFactory : AbstractRequestCallFactory() {
+class MultipartRequestCallFactory(logger: KSLog? = null) : AbstractRequestCallFactory(logger ?: DefaultKTgBotAPIKSLog) {
     override fun <T : Any> prepareCallBody(
         client: HttpClient,
         urlsKeeper: TelegramAPIUrlsKeeper,

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/bot/ktor/base/MultipleClientKtorRequestsExecutor.kt

@@ -1,12 +1,16 @@
 package dev.inmo.tgbotapi.bot.ktor.base
 
+import dev.inmo.kslog.common.KSLog
 import dev.inmo.micro_utils.coroutines.runCatchingSafely
 import dev.inmo.tgbotapi.bot.BaseRequestsExecutor
 import dev.inmo.tgbotapi.bot.ktor.KtorCallFactory
 import dev.inmo.tgbotapi.bot.ktor.KtorPipelineStepsHolder
+import dev.inmo.tgbotapi.bot.ktor.KtorRequestsExecutor
+import dev.inmo.tgbotapi.bot.settings.limiters.ExceptionsOnlyLimiter
 import dev.inmo.tgbotapi.bot.settings.limiters.RequestLimiter
 import dev.inmo.tgbotapi.requests.abstracts.Request
 import dev.inmo.tgbotapi.utils.TelegramAPIUrlsKeeper
+import dev.inmo.tgbotapi.utils.nonstrictJsonFormat
 import io.ktor.client.*
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.first
@@ -45,6 +49,7 @@ class MultipleClientKtorRequestsExecutor (
     jsonFormatter: Json,
     pipelineStepsHolder: KtorPipelineStepsHolder,
     requestExecutorsCount: Int,
+    logger: KSLog,
     clientFactory: () -> HttpClient
 ) : BaseRequestsExecutor(telegramAPIUrlsKeeper) {
     private val requestExecutors = (0 until requestExecutorsCount).map {
@@ -55,7 +60,9 @@ class MultipleClientKtorRequestsExecutor (
             excludeDefaultFactories,
             requestsLimiter,
             jsonFormatter,
-            pipelineStepsHolder
+            pipelineStepsHolder,
+            logger,
+            Unit
         )
     }.toSet()
     private val freeClients = MutableStateFlow<Set<DefaultKtorRequestsExecutor>>(requestExecutors)
@@ -68,14 +75,16 @@ class MultipleClientKtorRequestsExecutor (
         }
     }
 
-    constructor(
+    internal constructor(
         telegramAPIUrlsKeeper: TelegramAPIUrlsKeeper,
         client: HttpClient,
         callsFactories: List<KtorCallFactory>,
         excludeDefaultFactories: Boolean,
         requestsLimiter: RequestLimiter,
         jsonFormatter: Json,
-        pipelineStepsHolder: KtorPipelineStepsHolder
+        pipelineStepsHolder: KtorPipelineStepsHolder,
+        logger: KSLog,
+        diff: Unit
     ) : this(
         telegramAPIUrlsKeeper,
         callsFactories,
@@ -84,6 +93,7 @@ class MultipleClientKtorRequestsExecutor (
         jsonFormatter,
         pipelineStepsHolder,
         client.engineConfig.threadsCount,
+        logger,
         { platformClientCopy(client) }
     )
 

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/bot/ktor/base/SimpleRequestCallFactory.kt

@@ -1,12 +1,14 @@
 package dev.inmo.tgbotapi.bot.ktor.base
 
+import dev.inmo.kslog.common.KSLog
 import dev.inmo.tgbotapi.requests.abstracts.*
+import dev.inmo.tgbotapi.utils.DefaultKTgBotAPIKSLog
 import dev.inmo.tgbotapi.utils.TelegramAPIUrlsKeeper
 import io.ktor.client.HttpClient
 import io.ktor.http.ContentType
 import io.ktor.http.content.TextContent
 
-class SimpleRequestCallFactory : AbstractRequestCallFactory() {
+class SimpleRequestCallFactory(logger: KSLog? = null) : AbstractRequestCallFactory(logger ?: DefaultKTgBotAPIKSLog) {
     override fun <T : Any> prepareCallBody(
         client: HttpClient,
         urlsKeeper: TelegramAPIUrlsKeeper,

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/message/content/StoryContent.kt

@@ -7,7 +7,9 @@ import dev.inmo.tgbotapi.types.MessageId
 import dev.inmo.tgbotapi.types.MessageThreadId
 import dev.inmo.tgbotapi.types.buttons.KeyboardMarkup
 import dev.inmo.tgbotapi.types.chat.Chat
+import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
 import dev.inmo.tgbotapi.types.message.abstracts.Message
+import dev.inmo.tgbotapi.types.message.abstracts.PossiblyForwardedMessage
 import dev.inmo.tgbotapi.types.stories.Story
 import kotlinx.serialization.Serializable
 
@@ -25,7 +27,7 @@ data class StoryContent(
         replyToMessageId: MessageId?,
         allowSendingWithoutReply: Boolean?,
         replyMarkup: KeyboardMarkup?
-    ): Request<out Message> {
+    ): Request<PossiblyForwardedMessage> {
         return ForwardMessage(
             chat.id,
             toChatId = chatId,

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/utils/DefaultKSLog.kt

@@ -0,0 +1,11 @@
+package dev.inmo.tgbotapi.utils
+
+import dev.inmo.kslog.common.KSLog
+import dev.inmo.kslog.common.TagLogger
+
+/**
+ * Default realization of [KSLog] which will be used everywhere where there is no some custom variant of [KSLog]
+ *
+ * By default, uses [TagLogger] with tag `KTgBot` (which in fact falling back to [KSLog.default] with `KTgBot` default tag)
+ */
+var DefaultKTgBotAPIKSLog: KSLog = TagLogger("KTgBot")

tgbotapi.core/src/linuxArm64Main/kotlin/PackageInfo.kt

@@ -0,0 +1 @@
+package dev.inmo.tgbotapi

tgbotapi.core/src/linuxArm64Main/kotlin/bot/ktor/KtorRequestsExecutor.kt

@@ -0,0 +1,5 @@
+package dev.inmo.tgbotapi.bot.ktor
+
+import dev.inmo.tgbotapi.bot.ktor.base.MultipleClientKtorRequestsExecutor
+
+actual typealias KtorRequestsExecutor = MultipleClientKtorRequestsExecutor

tgbotapi.core/src/linuxArm64Main/kotlin/bot/ktor/base/ActualPlatformClientCopy.kt

@@ -0,0 +1,22 @@
+package dev.inmo.tgbotapi.bot.ktor.base
+
+import io.ktor.client.*
+import io.ktor.client.engine.cio.*
+
+/**
+ * This function is used in default constructor of [MultipleClientKtorRequestsExecutor] and on all non-native
+ * platforms and MingwX64 should return [client]
+ *
+ * On LinuxX64 it will create copy with Curl engine or throw an exception if engine is different with Curl
+ *
+ * @throws IllegalArgumentException When pass non Curl-based [HttpClient] on LinuxX64
+ */
+internal actual inline fun platformClientCopy(client: HttpClient): HttpClient = (client.engineConfig as? CIOEngineConfig) ?.let {
+    lateinit var config: HttpClientConfig<out CIOEngineConfig>
+    client.config {
+        config = this as HttpClientConfig<out CIOEngineConfig>
+    }.close()
+    HttpClient(CIO) {
+        this.plusAssign(config)
+    }
+} ?: throw IllegalArgumentException("On LinuxX64 TelegramBotAPI currently support only Curl Ktor HttpClient engine")

tgbotapi.core/src/linuxArm64Main/kotlin/requests/abstracts/ActualMPPFileAsMultipartFile.kt

@@ -0,0 +1,9 @@
+package dev.inmo.tgbotapi.requests.abstracts
+
+import dev.inmo.micro_utils.common.MPPFile
+import dev.inmo.micro_utils.ktor.common.input
+import dev.inmo.tgbotapi.requests.abstracts.MultipartFile
+
+actual fun MPPFile.asMultipartFile(): MultipartFile = MultipartFile(this.name) {
+    input()
+}

tgbotapi.core/src/linuxArm64Main/kotlin/utils/ActualByteReadChannelAsInput.kt

@@ -0,0 +1,7 @@
+package dev.inmo.tgbotapi.utils
+
+import io.ktor.utils.io.ByteReadChannel
+import io.ktor.utils.io.core.Input
+import io.ktor.utils.io.readRemaining
+
+actual suspend fun ByteReadChannel.asInput(): Input = readRemaining()

tgbotapi.core/src/linuxArm64Main/kotlin/utils/ActualMimeType.kt

@@ -0,0 +1,12 @@
+package dev.inmo.tgbotapi.utils
+
+import kotlinx.serialization.Serializable
+
+//actual typealias MimeType = MimeType
+
+@OptIn(RiskFeature::class)
+@Serializable(MimeTypeSerializer::class)
+actual data class MimeType(
+    actual val raw: String
+)
+internal actual fun createMimeType(raw: String): MimeType = MimeType(raw)

tgbotapi.core/src/linuxX64Main/kotlin/utils/ActualMimeType.kt

@@ -4,6 +4,7 @@ import kotlinx.serialization.Serializable
 
 //actual typealias MimeType = MimeType
 
+@OptIn(RiskFeature::class)
 @Serializable(MimeTypeSerializer::class)
 actual data class MimeType(
     actual val raw: String

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

@@ -24,6 +24,7 @@ class TelegramBotAPISymbolProcessor(
     private val outputFile: String = "Output",
     private val outputFolder: String? = null
 ) : SymbolProcessor {
+    @OptIn(RiskFeature::class)
     private val classCastsIncludedClassName = ClassCastsIncluded::class.asClassName()
     @OptIn(KspExperimental::class, RiskFeature::class)
     override fun process(resolver: Resolver): List<KSAnnotated> {

tgbotapi.utils/build.gradle

@@ -13,7 +13,7 @@ kotlin {
     sourceSets {
         commonMain {
             dependencies {
-                api project(":tgbotapi.core")
+                api project(path: ":tgbotapi.core")
             }
         }
     }

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

@@ -7,6 +7,7 @@ import dev.inmo.tgbotapi.types.message.abstracts.PossiblySentViaBotCommonMessage
 import dev.inmo.tgbotapi.types.message.content.MediaGroupPartContent
 import dev.inmo.tgbotapi.types.update.*
 import dev.inmo.tgbotapi.types.update.abstracts.*
+import dev.inmo.tgbotapi.utils.RiskFeature
 import dev.inmo.tgbotapi.utils.extensions.asMediaGroupMessage
 
 /**
@@ -22,6 +23,7 @@ fun List<Update>.lastUpdateIdentifier(): UpdateIdentifier? {
  * Will convert incoming list of [Update]s to list with [Update]s, which include [dev.inmo.tgbotapi.types.message.abstracts.ContentMessage]s
  * with [dev.inmo.tgbotapi.types.message.content.MediaGroupContent]
  */
+@OptIn(RiskFeature::class)
 fun List<Update>.convertWithMediaGroupUpdates(): List<Update> {
     val resultUpdates = mutableListOf<Update>()
     val mediaGroups = mutableMapOf<MediaGroupIdentifier, MutableList<Pair<BaseSentMessageUpdate, PossiblySentViaBotCommonMessage<MediaGroupPartContent>>>>()