botapi-py 1.1.0__py3-none-any.whl

botapi/core.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from . import types, errors
+
+from typing import Any, Generic, Literal, Optional, Dict, TypeVar, TypeAlias
+from pydantic import BaseModel
+
+import logging
+import httpx
+import json
+
+log = logging.getLogger(__name__)
+
+MultipartFile: TypeAlias = tuple[
+	str | None,
+	bytes,
+	Optional[str]
+] # (filename, file_content, mime_type)
+
+MultipartFiles: TypeAlias = dict[str, MultipartFile]
+
+
+class BaseBotAPI:
+	def __init__(
+		self,
+		token: str,
+		api_url: str = 'https://api.telegram.org',
+		session: Optional[httpx.AsyncClient] = None,
+		test_server: bool = False,
+	):
+		self.token: str = token.removeprefix('bot')
+		self.api_url: str = api_url
+		self.session: httpx.AsyncClient = session or httpx.AsyncClient(timeout=120)
+		self.test_server: bool = test_server
+		
+		if not session:
+			log.warning('No HTTP session provided, creating a new one.')
+			
+	def _compose_api_url(self, method: str) -> str:
+		url = f'{self.api_url}/bot{self.token}/'
+		if self.test_server:
+			url += 'test/'
+		url += method
+		return url
+
+	def _convert_data(self, data: dict[str, Any]) -> tuple[dict[str, Any], MultipartFiles]:
+		new_data: dict[str, Any] = {}
+		files: MultipartFiles = {} # (filename, file_content, mime_type)
+		
+		for key, value in data.items():
+			
+			# Multipart file uploading from local file
+			'''
+			#TODO (is it a good idea?) infer the parameter even if it's always a string (not wrapped inside a InputFile instance):
+			 - if it's a local file path, send the string as-is if in local botapi mode, otherwise open, read and use multipart
+			 - if it's a remote file URL or a file_id, send it as-is to the api
+			>> but i need to evaluate if it's worth the convenience, because when we pass a local path that points to a non-existing file
+				this would consider the string to be a file_id (and yes, it would throw an error, but it would be harder to debug).
+			'''
+			if isinstance(value, types.InputFile):
+				# if value.path:
+				# 	with open(value.path, 'rb') as f:
+				# 		file_content = f.read()
+				# elif value.file_content:
+				
+				file_content = value.file_content
+				files[key] = (value.file_name, file_content, value.mime_type) # if mime_type is None, httpx will infer it with `mimetypes`
+				# continue
+				
+			elif isinstance(value, BaseModel):
+				new_data[key] = json.dumps(
+					value.model_dump(
+						mode='json',
+						exclude_none=True,
+					)   
+				)
+				
+			elif isinstance(value, list):
+				new_data[key] = json.dumps([
+					item.model_dump(
+						mode='json',
+						exclude_none=True,
+					)
+					if isinstance(item, BaseModel)
+					else item for item in value # pyright: ignore[reportUnknownVariableType]
+				])
+				
+			else:
+				new_data[key] = value
+				
+		return new_data, files
+
+	async def _send_request(self, method: str, data: Dict[str, Any]) -> Any:
+		converted_data, files = self._convert_data(data)
+		
+		request = await self.session.post(
+			url=self._compose_api_url(method),
+			data=converted_data,
+			files=files or None
+		)
+		result: dict[str, Any] = request.json()
+		
+		if not result['ok']:
+			raise errors.BotAPIError(
+				method=method,
+				response=result
+			)
+			
+		return result['result']
+

botapi/enums.py

@@ -0,0 +1,30 @@
+import enum
+
+class ChatType(enum.Enum):
+	PRIVATE = 'private'
+	GROUP = 'group'
+	SUPERGROUP = 'supergroup'
+	CHANNEL = 'channel'
+	
+class MessageType(enum.Enum):
+	TEXT = 'text'
+	ANIMATION = 'animation'
+	AUDIO = 'audio'
+	DOCUMENT = 'document'
+	PAID_MEDIA = 'paid_media'
+	PHOTO = 'photo'
+	STICKER = 'sticker'
+	STORY = 'story'
+	VIDEO = 'video'
+	VIDEO_NOTE = 'video_note'
+	VOICE = 'voice'
+	CHECKLIST = 'checklist'
+	CONTACT = 'contact'
+	DICE = 'dice'
+	GAME = 'game'
+	POLL = 'poll'
+	VENUE = 'venue'
+	LOCATION = 'location'
+	INVOICE = 'invoice'
+	GIVEAWAY = 'giveaway'
+	

botapi/errors.py

@@ -0,0 +1,34 @@
+import json
+
+from typing import Any, Optional
+
+from . import types
+
+
+class BotAPIError(Exception):
+	"""
+	Exception raised for Bot API request failures.
+	
+	Args:
+		method (`str`): The method name of the failed API call.
+		error_code (`int`, optional): Numeric error code when request fails.
+		description (`str`, optional): Human-readable error description.
+		parameters (`ResponseParameters`, optional): Additional error handling parameters.
+	"""
+	
+	method: str
+	response: dict[str, Any]
+	error_code: Optional[int] = None
+	description: Optional[str] = None
+	parameters: Optional[types.ResponseParameters] = None
+	
+	def __init__(self, method: str, response: dict[str, Any]):
+		self.method = method
+		self.response = response
+		self.error_code = response.get('error_code')
+		self.description = response.get('description')
+		_parameters = response.get('parameters')
+		self.parameters = types.ResponseParameters.model_validate(_parameters) if _parameters else None
+		
+		Exception.__init__(self, f'BotAPI request failed: /{self.method}: {json.dumps(self.response, indent=True)}')
+