lineoa 4.4.3__tar.gz

lineoa-4.4.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 もやし
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lineoa-4.4.3/LINELib/AuthService.py

@@ -0,0 +1,203 @@
+from typing import Optional, List, Dict, Any, Callable
+import urllib.parse
+import requests
+import os
+import json
+import time
+from .exceptions import LINEOAError
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+
+class AuthService:
+	def get_uid_map_from_at_ids(self, at_id_list: List[str], chat_service: Any) -> Dict[str, str]:
+		"""
+		Get a map from @ID list to U-ID (internal ID)
+		:param at_id_list: ['@xxxx', ...]
+		:param chat_service: ChatService instance
+		:return: dict {@id: u_id}
+		 """
+		uid_map = {}
+		try:
+			bot_accounts = chat_service.get_bot_accounts()
+			for bot in bot_accounts.get('list', []):
+				at_id = bot.get('basicSearchId')
+				u_id = bot.get('botId')
+				if at_id and u_id and at_id in at_id_list:
+					uid_map[at_id] = u_id
+		except Exception as e:
+			LINEOAError(f"Failed to get UID map from @IDs: {e}")
+		return uid_map
+	def __init__(self, channel_id: Optional[str] = None, channel_secret: Optional[str] = None, access_token: Optional[str] = None, cookie_store_path: Optional[str] = None):
+		self.channel_id = channel_id
+		self.channel_secret = channel_secret
+		self.access_token = access_token
+		self.cookie_store_path = cookie_store_path
+
+	def login_with_email_and_2fa(self, email: Optional[str], password: Optional[str], get_2fa_code_callback: Optional[Callable], recaptcha_response: str = "", stay_logged_in: bool = True, xsrf_token: Optional[str] = None, cookies: Optional[Dict[str, str]] = None) -> Dict[str, Any]:
+		# Cookie storage
+		if self.cookie_store_path and os.path.exists(self.cookie_store_path):
+			if os.path.getsize(self.cookie_store_path) == 0:
+				raise LINEOAError("Cookie storage load error: cookie file is empty. Please save logged-in cookies.")
+			try:
+				with open(self.cookie_store_path, "r", encoding="utf-8") as f:
+					data = json.load(f)
+				if data.get("email") == email and "cookies" in data:
+					session = requests.Session()
+					for c in data["cookies"]:
+						session.cookies.set(c["name"], c["value"], domain=c.get("domain"))
+					chat_cookies = {c["name"] for c in data["cookies"] if c.get("domain") == "chat.line.biz"}
+					for c in data["cookies"]:
+						if c["name"] not in chat_cookies and c.get("domain") in [".line.biz", ".manager.line.biz", "manager.line.biz", "account.line.biz"]:
+							session.cookies.set(c["name"], c["value"], domain="chat.line.biz")
+					user_info = {"user_name": data.get("user_name")}
+					return {"session": session, "user_info": user_info}
+			except Exception as e:
+				raise LINEOAError(f"Cookie storage load error: {e}")
+		if email is None and password is None:
+			session = requests.Session()
+			user_info = {"user_name": None}
+			login_url = "https://account.line.biz/login?redirectUri=https%3A%2F%2Faccount.line.biz%2Foauth2%2Fcallback%3Fclient_id%3D10%26code_challenge%3D4x53SnbmZOYxDeiDFpINCIeh9t1HYiSmIY2E7CblxVY%26code_challenge_method%3DS256%26redirect_uri%3Dhttps%253A%252F%252Fmanager.line.biz%252Fapi%252Foauth2%252FbizId%252Fcallback%26response_type%3Dcode%26state%3DUxTSXVJiwgOWD4cnrk68RCXBwhPLPkBI"
+			chrome_options = Options()
+			chrome_options.add_experimental_option("detach", True)
+			driver = webdriver.Chrome(options=chrome_options)
+			driver.get(login_url)
+			while True:
+				time.sleep(2)
+				try:
+					current_url = driver.current_url
+					if current_url.startswith("https://manager.line.biz/"):
+						break
+				except Exception as e:
+					raise LINEOAError(f"Error while checking current URL: {e}")
+			driver.get("https://chat.line.biz/")
+			time.sleep(2)
+			driver.get("https://chat.line.biz/api/v1/bots?limit=1000&noFilter=true")
+			time.sleep(2)
+			bots_json = None
+			try:
+				pre = driver.find_element("tag name", "pre")
+				bots_json = json.loads(pre.text)
+			except Exception:
+				try:
+					bots_json = json.loads(driver.find_element("tag name", "body").text)
+				except Exception as e:
+					raise LINEOAError(f"Failed to parse bots JSON: {e}")
+			bot_ids = [b["botId"] for b in bots_json.get("list", []) if b.get("botId", "").startswith("U")]
+			all_cookies = driver.get_cookies()[:]
+			for bot_id in bot_ids:
+				url = f"https://chat.line.biz/{bot_id}"
+				driver.get(url)
+				time.sleep(2)
+				all_cookies.extend(driver.get_cookies())
+			driver.quit()
+			seen = set()
+			combined_cookies_to_save = []
+			for cookie in all_cookies:
+				try:
+					key = (cookie['name'], cookie.get('domain'))
+					if key not in seen:
+						combined_cookies_to_save.append({
+							"name": cookie['name'],
+							"value": cookie['value'],
+							"domain": cookie.get('domain')
+						})
+						seen.add(key)
+				except Exception as e:
+					raise LINEOAError(f"Error while processing cookies: {e}")
+			for c in combined_cookies_to_save:
+				try:
+					session.cookies.set(c["name"], c["value"], domain=c.get("domain"))
+				except Exception as e:
+					raise LINEOAError(f"Error while setting session cookies: {e}")
+			if self.cookie_store_path:
+				try:
+					with open(self.cookie_store_path, "w", encoding="utf-8") as f:
+						json.dump({
+							"user_name": user_info.get("user_name"),
+							"cookies": combined_cookies_to_save
+						}, f, ensure_ascii=False, indent=2)
+				except Exception as e:
+					raise LINEOAError(f"Cookie storage save error: {e}")
+			return {"session": session, "user_info": user_info, "bot_ids": bot_ids}
+		raise LINEOAError("login_with_email_and_2fa failed: no valid login path")
+
+	def login_and_get_token(self, email: str, password: str, client_id: str, code_challenge: str, redirect_uri: str, state: str, session: Optional[requests.Session] = None) -> Optional[str]:
+		"""
+		Automate OAuth2 authentication flow with email and password only to obtain authorization code (code) template
+		:param email: Email address
+		:param password: Password
+		:param client_id: OAuth2 client ID
+		:param code_challenge: PKCE challenge
+		:param redirect_uri: Redirect URI
+		:param state: state parameter
+		:param session: requests.Session (newly created if omitted)
+		:return: code (authorization code) or None
+		 """
+		session = session or requests.Session()
+		xsrf_resp = session.get("https://chat.line.biz/api/v1/csrfToken")
+		xsrf_token = xsrf_resp.json().get("token")
+		login_resp = self.login_with_email(
+			email, password, recaptcha_response="", stay_logged_in=True, xsrf_token=xsrf_token, cookies=session.cookies.get_dict()
+		)
+		if login_resp.get("status") == "needReCaptchaVerification":
+			raise LINEOAError("reCAPTCHA verification is required. Manual intervention or external service integration is needed.")
+		params = {
+			"client_id": client_id,
+			"code_challenge": code_challenge,
+			"code_challenge_method": "S256",
+			"redirect_uri": redirect_uri,
+			"response_type": "code",
+			"state": state,
+			"status": "success"
+		}
+		auth_url = "https://account.line.biz/oauth2/callback?" + urllib.parse.urlencode(params)
+		resp = session.get(auth_url, allow_redirects=False)
+		if resp.status_code == 302 and "location" in resp.headers:
+			loc = resp.headers["location"]
+			parsed = urllib.parse.urlparse(loc)
+			query = urllib.parse.parse_qs(parsed.query)
+			code = query.get("code", [None])[0]
+			return code
+		raise LINEOAError("Failed to obtain authorization code")
+
+	def get_access_token(self) -> str:
+		"""
+		Extend to implement access token acquisition API, etc.
+		:return: Access token string
+		:raises LINEOAError: When not set
+		 """
+		if self.access_token:
+			return self.access_token
+		raise LINEOAError("Access Token is not set")
+
+	def login_with_email(self, email: str, password: str, recaptcha_response: str = "", stay_logged_in: bool = True, xsrf_token: Optional[str] = None, cookies: Optional[Dict[str, str]] = None) -> Dict[str, Any]:
+		"""
+		Log in to LINE Business Account with email and password
+		POST https://account.line.biz/api/login/email
+		:param email: Email address
+		:param password: Password
+		:param recaptcha_response: reCAPTCHA response (if needed)
+		:param stay_logged_in: Stay logged in
+		:param xsrf_token: XSRF token (if needed)
+		:param cookies: Session cookies (if needed)
+		:return: dict (API response)
+		 """
+		url = "https://account.line.biz/api/login/email"
+		headers = {
+			"Content-Type": "application/json",
+			"Accept": "application/json, text/plain, */*"
+		}
+		if xsrf_token:
+			headers["x-xsrf-token"] = xsrf_token
+		payload = {
+			"email": email,
+			"password": password,
+			"gRecaptchaResponse": recaptcha_response,
+			"stayLoggedIn": stay_logged_in
+		}
+		try:
+			response = requests.post(url, headers=headers, json=payload, cookies=cookies)
+			response.raise_for_status()
+			return response.json()
+		except Exception as e:
+			raise LINEOAError(f"login_with_email failed: {e}")

lineoa-4.4.3/LINELib/LINELib.py

@@ -0,0 +1,253 @@
+from typing import Optional, List, Dict, Any, Callable
+from .AuthService import AuthService
+from .chatService import ChatService
+from .exceptions import LINEOAError
+import os
+import requests
+import json
+import time
+import random
+
+class LINELib:
+    def get_streaming_api_token_and_listen_stream_events(self, bot_id: str, device_type: str = "", client_type: str = "PC", ping_secs: int = 60, last_event_id: Optional[str] = None, on_event: Optional[Callable[[Dict[str, Any]], None]] = None) -> None:
+        """
+        streamingApiToken取得→SSE接続を一連で行う
+        :param bot_id: BotのID
+        :param device_type: デバイスタイプ（省略可）
+        :param client_type: クライアントタイプ（デフォルト: PC）
+        :param ping_secs: ping間隔（デフォルト: 60秒）
+        :param last_event_id: 前回受信したイベントID（省略可）
+        :param on_event: イベント受信時のコールバック (dict)
+        """
+        try:
+            token_info = self._chat_service.get_streaming_api_token(bot_id, session=self._session, xsrf_token=self._xsrf_token)
+            streaming_api_token = token_info.get("streamingApiToken")
+            if not isinstance(streaming_api_token, str) or not streaming_api_token:
+                raise LINEOAError("streamingApiToken is missing or invalid")
+            last_event_id = last_event_id or token_info.get("lastEventId")
+            for event in self._chat_service.stream_events(
+                streaming_api_token,
+                device_type=device_type,
+                client_type=client_type,
+                ping_secs=ping_secs,
+                last_event_id=last_event_id,
+                session=self._session,
+                xsrf_token=self._xsrf_token
+            ):
+                if on_event:
+                    on_event(event)
+        except Exception as e:
+            print("[EXCEPTION in get_streaming_api_token_and_listen_stream_events]", e)
+
+    def get_chat_members(self, bot_id=None, chat_id=None, limit: int = 100) -> Dict[str, Any]:
+        """チャットメンバー一覧取得"""
+        return self._chat_service.get_chat_members(
+            bot_id=str(bot_id), chat_id=str(chat_id), limit=limit, session=self._session, xsrf_token=self._xsrf_token
+        )
+
+    def send_file(self, chat_id: str, file_path: str, bot_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+        指定チャットにファイルを送信
+        :param chat_id: チャットID
+        :param file_path: ファイルパス
+        :param bot_id: 利用するbotId（省略時は先頭bot）
+        """
+        if bot_id is None:
+            bot_id = next(iter(self.bots.ids.values()), None)
+        if not bot_id:
+            raise LINEOAError("No bot found")
+        return self._chat_service.send_file(
+            bot_id, chat_id, file_path, session=self._session, xsrf_token=self._xsrf_token
+        )
+    
+    def listen_stream_events(self, streaming_api_token: str, device_type: str = "", client_type: str = "PC", ping_secs: int = 60, last_event_id: Optional[str] = None, on_event: Optional[Callable[[Dict[str, Any]], None]] = None) -> None:
+        """
+        chat-streaming-api.line.biz SSEイベント受信
+        :param streaming_api_token: SSE用トークン
+        :param device_type: デバイスタイプ（省略可）
+        :param client_type: クライアントタイプ（デフォルト: PC）
+        :param ping_secs: ping間隔（デフォルト: 60秒）
+        :param last_event_id: 前回受信したイベントID（省略可）
+        :param on_event: イベント受信時のコールバック (dict)
+        """
+        for event in self._chat_service.stream_events(
+            streaming_api_token,
+            device_type=device_type,
+            client_type=client_type,
+            ping_secs=ping_secs,
+            last_event_id=last_event_id,
+            session=self._session,
+            xsrf_token=self._xsrf_token
+        ):
+            if on_event:
+                on_event(event)
+
+    def get_chat_messages(self, bot_id: str, chat_id: str, limit: int = 50, before: Optional[str] = None, after: Optional[str] = None) -> Dict[str, Any]:
+        """
+        指定チャットのメッセージ一覧を取得 (公式Webクライアント完全再現)
+        :param bot_id: BotのID
+        :param chat_id: チャットID
+        :param limit: 取得件数
+        :param before: これより前のメッセージID（任意）
+        :param after: これより後のメッセージID（任意）
+        :return: dict (list: メッセージ情報配列)
+        """
+        return self._chat_service.get_chat_messages(
+            bot_id, chat_id,
+            session=self._session,
+            xsrf_token=self._xsrf_token,
+            limit=limit,
+            before=before,
+            after=after
+        )
+
+    def __init__(self, storage: Optional[str] = None):
+        self.storage = storage or "lineoa-storage.json"
+        self._auth = AuthService(cookie_store_path=self.storage)
+        self._session = None
+        self._user_info = None
+        self._xsrf_token = None
+        try:
+            self._restore_session_from_cookie()
+        except LINEOAError as e:
+            login_result = self._auth.login_with_email_and_2fa(None, None, get_2fa_code_callback=None)
+            self._session = login_result.get("session")
+            self._user_info = login_result.get("user_info")
+            for c in self._session.cookies:
+                if c.name == "XSRF-TOKEN" and "chat.line.biz" in c.domain:
+                    self._xsrf_token = c.value
+                    break
+        if self._session is None:
+            self._session = requests.Session()
+        self._chat_service = ChatService("")
+        self._bots = None
+        self._chats = None
+        self._provider = None
+
+    def listen_messages(self, bot_id: str, chat_id: str, on_message: Optional[Callable[[Dict[str, Any]], None]] = None) -> None:
+        """
+        指定チャットのメッセージをリアルタイムで監視 (SSE)
+        :param bot_id: BotのID
+        :param chat_id: チャットID
+        :param on_message: 新着メッセージ受信時のコールバック (dict)
+        """
+        return self._chat_service.listen_messages(bot_id, chat_id, on_message)
+
+    def send_message(self, user_id: str, context: str, bot_id: Optional[str] = None, quoteToken: Optional[str] = None) -> Dict[str, Any]:
+        """
+        指定ユーザーにテキストメッセージを送信
+        :param user_id: チャットID（ユーザーID）
+        :param context: 送信するテキスト
+        :param bot_id: 利用するbotId（省略時は先頭bot）
+        :param quoteToken: リプライ用(省略時は普通のメッセージ)
+        """
+        if bot_id is None:
+            bot_id = next(iter(self.bots.ids.values()), None)
+        if not bot_id:
+            raise LINEOAError("No bot found")
+        now = int(time.time() * 1000)
+        send_id = f"{user_id}_{now}_{random.randint(1000000,9999999)}"
+        payload = {
+            "id": "",
+            "type": "textV2",
+            "text": context,
+            "sendId": send_id
+        }
+        if quoteToken:
+            payload["quoteToken"] = quoteToken
+        return self._chat_service.send_message(
+            bot_id, user_id, payload, session=self._session, xsrf_token=self._xsrf_token
+        )
+
+    def _restore_session_from_cookie(self) -> None:
+        if not os.path.exists(self.storage):
+            raise LINEOAError("cookie storage does not exist. Please save logged-in cookies.")
+        if os.path.getsize(self.storage) == 0:
+            raise LINEOAError("cookie storage is empty. Please save logged-in cookies.")
+        with open(self.storage, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        if "cookies" not in data:
+            raise LINEOAError("cookie storage is invalid")
+        session = requests.Session()
+        for c in data["cookies"]:
+            session.cookies.set(c["name"], c["value"], domain=c.get("domain"))
+        self._session = session
+        self._user_info = {"email": data.get("email"), "user_name": data.get("user_name")}
+        for c in session.cookies:
+            if c.name == "XSRF-TOKEN" and "chat.line.biz" in c.domain:
+                self._xsrf_token = c.value
+                break
+
+    @property
+    def bots(self):
+        if self._bots is None:
+            bots = self._chat_service.get_bot_accounts(session=self._session, xsrf_token=self._xsrf_token)
+            # bots: list of dicts with 'botId' and 'name'
+            self._bots = BotsInfo(bots.get("list", []))
+        return self._bots
+
+    @property
+    def chats(self):
+        if self._chats is None:
+            bot_id = next(iter(self.bots.ids.values()), None)
+            if not bot_id:
+                raise LINEOAError("No bot found")
+            try:
+                chats = self._chat_service.get_chats(bot_id, session=self._session, xsrf_token=self._xsrf_token)
+                self._chats = ChatsInfo(chats.get("list", []))
+            except Exception as e:
+                raise LINEOAError(f"チャット一覧取得失敗: {e}")
+        return self._chats
+
+    @property
+    def provider(self):
+        if self._provider is None:
+            try:
+                url = "https://chat.line.biz/api/v1/providers"
+                headers = {
+                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36",
+                    "Accept": "application/json, text/plain, */*",
+                }
+                if self._session is None:
+                    self._session = requests.Session()
+                resp = self._session.get(url, headers=headers)
+                if resp.ok:
+                    self._provider = resp.json()
+                else:
+                    self._provider = []
+                    raise LINEOAError(f"get Provider Not found: {resp.status_code} {resp.text}")
+            except Exception as e:
+                self._provider = []
+                raise LINEOAError(f"get Provider Error: {e}")
+        return self._provider
+
+class BotsInfo:
+    def __init__(self, bots_list: List[Dict[str, Any]]):
+        self._bots = bots_list
+    @property
+    def ids(self) -> Dict[str, str]:
+        result = {}
+        for b in self._bots:
+            u_id = b.get("botId")
+            at_id = b.get("basicSearchId")
+            name = b.get("name", "")
+            if u_id:
+                key = at_id if at_id else name
+                result[key] = u_id
+        return result
+
+class ChatsInfo:
+    def __init__(self, chats_list: List[Dict[str, Any]]):
+        self._chats = chats_list
+        self.group = ChatTypeIds(self._chats, "GROUP")
+        self.user = ChatTypeIds(self._chats, "USER")
+
+class ChatTypeIds:
+    def __init__(self, chats: List[Dict[str, Any]], chat_type: str):
+        self._ids = [c["chatId"] for c in chats if c.get("chatType") == chat_type]
+    @property
+    def ids(self) -> List[str]:
+        return self._ids
+
+
+

lineoa-4.4.3/LINELib/__init__.py

@@ -0,0 +1,19 @@
+from .linebot import LineBot
+
+__all__ = ["LineBot"]
+from .chatService import ChatService
+from .AuthService import AuthService
+from .exceptions import LINEOAError
+from .util import merge_dicts
+from .LINELib import LINELib
+from typing import Any
+
+__all__ = ["ChatService", "AuthService", "LINEOAError", "merge_dicts"]
+__author__ = "madoa5561"
+__version__ = "4.4.3"
+__license__ = "MIT"
+
+
+
+
+