WPP-Whatsapp 0.2.1__tar.gz

WPP_Whatsapp-0.2.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Ammar
+
+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.

WPP_Whatsapp-0.2.1/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.1
+Name: WPP_Whatsapp
+Version: 0.2.1
+Summary: WPP_Whatsapp aim of exporting functions from WhatsApp Web to the python, which can be used to support the creation of any interaction, such as customer service, media sending, intelligence recognition based on phrases artificial and many other things, use your imagination
+Home-page: https://github.com/3mora2/WPP_Whatsapp
+Author: Ammar Alkotb
+Author-email: ammar.alkotb@gmail.com
+License: MIT License
+Project-URL: Bug Report, https://github.com/3mora2/WPP_Whatsapp/issues/new
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: event-emitter-js
+Requires-Dist: greenlet
+Requires-Dist: playwright
+Requires-Dist: Pillow
+Requires-Dist: psutil
+Requires-Dist: pyee
+Requires-Dist: segno
+Requires-Dist: typing_extensions
+Requires-Dist: playwright-stealth
+Requires-Dist: node-semver
+Requires-Dist: aiohttp
+Requires-Dist: PlaywrightSafeThread>=0.5.2.1
+
+# WPP_Whatsapp
+<p align="center">
+  <a href="https://pypi.org/project/WPP-Whatsapp"><img alt="PyPI Version" src="https://img.shields.io/pypi/v/WPP_Whatsapp.svg?maxAge=86400" /></a>
+  <a href="https://pypi.org/project/WPP-Whatsapp"><img alt="View" src="https://static.pepy.tech/personalized-badge/WPP_Whatsapp?period=total&units=international_system&left_text=Downloads"/></a>
+</p>
+
+WPP_Whatsapp aim of exporting functions from WhatsApp Web to the python, which can be used to support the creation of
+any interaction, such as customer service, media sending, intelligence recognition based on phrases artificial and many
+other things, use your imagination         
+WPP_Whatsapp > [WPPConnect](https://github.com/wppconnect-team/wppconnect) Converted to python, so Documentation is same
+
+
+## Online channels
+
+[![Telegram Group](https://img.shields.io/badge/Telegram-Group-32AFED?logo=telegram)](https://t.me/WPP_Whatsapp)
+
+## Functions
+
+|                                                            |   |
+|------------------------------------------------------------|---|
+| Automatic QR Refresh                                       | ✔ |
+| Send **text, image, video, audio and docs**                | ✔ |
+| Get **contacts, chats, groups, group members, Block List** | ✔ |
+| Send contacts                                              | ✔ |
+| Send stickers                                              | ✔ |
+| Send stickers GIF                                          | ✔ |
+| Multiple Sessions                                          | ✔ |
+| Forward Messages                                           | ✔ |
+| Receive message                                            | ✔ |
+| insert user section                                        | ✔ |
+| Send _location_                                            | ✔ |
+| **and much more**                                          | ✔ |
+
+See more at <a href="https://wppconnect.io/wppconnect/classes/Whatsapp.html">WhatsApp methods</a>
+## Getting Started
+
+### Installation
+
+installed with [pip](https://pip.pypa.io):
+```commandline
+pip install WPP_Whatsapp -U
+```
+Alternatively, you can grab the latest source code from [GitHub](https://github.com/3mora2/WPP_Whatsapp):
+
+```
+pip install git+https://github.com/3mora2/WPP_Whatsapp
+```
+
+
+
+### Send Text
+
+```python
+from WPP_Whatsapp import Create
+
+# start client with your session name
+your_session_name = "test"
+creator = Create(session=your_session_name)
+client = creator.start()
+# Now scan Whatsapp Qrcode in browser
+
+# check state of login
+if creator.state != 'CONNECTED':
+    raise Exception(creator.state)
+
+phone_number = "201016708170"  # or "+201016708170"
+message = "hello from wpp"
+
+# Simple message
+result = client.sendText(phone_number, message)
+```
+
+### Receive Messages(Auto Replay)
+```python
+from WPP_Whatsapp import Create
+
+# start client with your session name
+your_session_name = "test"
+creator = Create(session=your_session_name)
+client = creator.start()
+# Now scan Whatsapp Qrcode in browser
+
+# check state of login
+if creator.state != 'CONNECTED':
+    raise Exception(creator.state)
+
+
+def new_message(message):
+    global client
+    # Add your Code here
+    if message and not message.get("isGroupMsg"):
+        chat_id = message.get("from")
+        message_id = message.get("id")
+        if "السلام عليكم" in message.get("body"):
+            client.reply(chat_id, "وعليكم السلام", message_id)
+        else:
+            client.reply(chat_id, "Welcome", message_id)
+
+
+# Add Listen To New Message
+creator.client.onMessage(new_message)
+```
+
+### <a href="https://github.com/3mora2/WPP_Whatsapp/tree/main/examples">For More Examples</a>

WPP_Whatsapp-0.2.1/README.md

@@ -0,0 +1,104 @@
+# WPP_Whatsapp
+<p align="center">
+  <a href="https://pypi.org/project/WPP-Whatsapp"><img alt="PyPI Version" src="https://img.shields.io/pypi/v/WPP_Whatsapp.svg?maxAge=86400" /></a>
+  <a href="https://pypi.org/project/WPP-Whatsapp"><img alt="View" src="https://static.pepy.tech/personalized-badge/WPP_Whatsapp?period=total&units=international_system&left_text=Downloads"/></a>
+</p>
+
+WPP_Whatsapp aim of exporting functions from WhatsApp Web to the python, which can be used to support the creation of
+any interaction, such as customer service, media sending, intelligence recognition based on phrases artificial and many
+other things, use your imagination         
+WPP_Whatsapp > [WPPConnect](https://github.com/wppconnect-team/wppconnect) Converted to python, so Documentation is same
+
+
+## Online channels
+
+[![Telegram Group](https://img.shields.io/badge/Telegram-Group-32AFED?logo=telegram)](https://t.me/WPP_Whatsapp)
+
+## Functions
+
+|                                                            |   |
+|------------------------------------------------------------|---|
+| Automatic QR Refresh                                       | ✔ |
+| Send **text, image, video, audio and docs**                | ✔ |
+| Get **contacts, chats, groups, group members, Block List** | ✔ |
+| Send contacts                                              | ✔ |
+| Send stickers                                              | ✔ |
+| Send stickers GIF                                          | ✔ |
+| Multiple Sessions                                          | ✔ |
+| Forward Messages                                           | ✔ |
+| Receive message                                            | ✔ |
+| insert user section                                        | ✔ |
+| Send _location_                                            | ✔ |
+| **and much more**                                          | ✔ |
+
+See more at <a href="https://wppconnect.io/wppconnect/classes/Whatsapp.html">WhatsApp methods</a>
+## Getting Started
+
+### Installation
+
+installed with [pip](https://pip.pypa.io):
+```commandline
+pip install WPP_Whatsapp -U
+```
+Alternatively, you can grab the latest source code from [GitHub](https://github.com/3mora2/WPP_Whatsapp):
+
+```
+pip install git+https://github.com/3mora2/WPP_Whatsapp
+```
+
+
+
+### Send Text
+
+```python
+from WPP_Whatsapp import Create
+
+# start client with your session name
+your_session_name = "test"
+creator = Create(session=your_session_name)
+client = creator.start()
+# Now scan Whatsapp Qrcode in browser
+
+# check state of login
+if creator.state != 'CONNECTED':
+    raise Exception(creator.state)
+
+phone_number = "201016708170"  # or "+201016708170"
+message = "hello from wpp"
+
+# Simple message
+result = client.sendText(phone_number, message)
+```
+
+### Receive Messages(Auto Replay)
+```python
+from WPP_Whatsapp import Create
+
+# start client with your session name
+your_session_name = "test"
+creator = Create(session=your_session_name)
+client = creator.start()
+# Now scan Whatsapp Qrcode in browser
+
+# check state of login
+if creator.state != 'CONNECTED':
+    raise Exception(creator.state)
+
+
+def new_message(message):
+    global client
+    # Add your Code here
+    if message and not message.get("isGroupMsg"):
+        chat_id = message.get("from")
+        message_id = message.get("id")
+        if "السلام عليكم" in message.get("body"):
+            client.reply(chat_id, "وعليكم السلام", message_id)
+        else:
+            client.reply(chat_id, "Welcome", message_id)
+
+
+# Add Listen To New Message
+creator.client.onMessage(new_message)
+```
+
+### <a href="https://github.com/3mora2/WPP_Whatsapp/tree/main/examples">For More Examples</a>

WPP_Whatsapp-0.2.1/WPP_Whatsapp/README.md

@@ -0,0 +1,10 @@
+I am try use playwright as threadsafe
+and try all function sync but in event function
+like `page.on("event", func)` must use async function,
+may be playwright exec only one sync function in same time, 
+so if you need more use them as async
+
+now all function has two type 
+
+- one relate to event (play in background) like `page.on` need use async and await
+- other not relate to event, use without async and await

WPP_Whatsapp-0.2.1/WPP_Whatsapp/__init__.py

@@ -0,0 +1,5 @@
+from WPP_Whatsapp.controllers.browser import ThreadsafeBrowser
+from WPP_Whatsapp.api.Whatsapp import Whatsapp
+from WPP_Whatsapp.controllers.initializer import Create
+
+

WPP_Whatsapp-0.2.1/WPP_Whatsapp/api/Whatsapp.py

@@ -0,0 +1,141 @@
+import asyncio
+from WPP_Whatsapp.api.helpers.jsFunction import setInterval
+from WPP_Whatsapp.api.layers.HostLayer import HostLayer
+from WPP_Whatsapp.api.const import defaultOptions, Logger
+from WPP_Whatsapp.api.layers.BusinessLayer import BusinessLayer
+from WPP_Whatsapp.api.layers.ListenerLayer import ListenerLayer
+
+
+class Whatsapp(BusinessLayer):
+    interval: asyncio.Event
+
+    def __init__(self, session, threadsafe_browser, version=None, **kwargs):
+        self.connected = None
+        self.options = {}
+        self.options.update(defaultOptions)
+        for key, value in kwargs.items():
+            if key in self.options:
+                self.options[key] = value
+
+        # self.autoCloseInterval = None
+        self.version = version
+        self.autoCloseCalled = False
+        self.isInitialized = False
+        self.isInjected = False
+        self.isStarted = False
+        self.isLogged = False
+        self.isInChat = False
+        # self.checkStartInterval = None
+        self.urlCode = ''
+        self.status = ''
+        self.attempt = 0
+        self.lastPercent = ""
+        self.lastPercentMessage = ""
+        self.session = session
+        self.page = threadsafe_browser.page
+        self.browser = threadsafe_browser.browser
+        self.ThreadsafeBrowser = threadsafe_browser
+        self.loop = threadsafe_browser.loop
+        self.logger = self.options.get("logger") or Logger
+        self.logger.info(f'{self.session}: Initializing...')
+        self.logQR = kwargs.get("logQR") or False
+        self.autoClose = kwargs.get("autoClose") or self.options.get("autoClose") or 60
+        HostLayer.__init__(self)
+        ListenerLayer.__init__(self)
+        self.handel()
+
+    def handel(self):
+        # self.interval = None
+        if self.page:
+            self.interval = setInterval(self.loop, self.__intervalHandel, 60)
+            self.page.on('close', self.clear_all_interval)
+
+    async def clear_all_interval(self, *args, **kwargs):
+        Logger.info("clear all intervals")
+        if hasattr(self, "interval"):
+            self.clearInterval(self.interval)
+        if hasattr(self, "autoCloseInterval"):
+            self.clearInterval(self.autoCloseInterval)
+        if hasattr(self, "checkStartInterval"):
+            self.clearInterval(self.checkStartInterval)
+
+    # @staticmethod
+    # def __setInterval(func, interval, *args, **kwargs):
+    #     stopped = threading.Event()
+    #
+    #     def _loop_():
+    #         while not stopped.is_set():
+    #             func()
+    #             time.sleep(interval)
+    #
+    #     th = threading.Thread(target=_loop_)
+    #     th.start()
+    #     return stopped
+
+    async def __intervalHandel(self):
+        try:
+            # Add window, when WPP not  create yet
+            newConnected = await self.ThreadsafeBrowser.page_evaluate("() => typeof window.WPP !== 'undefined' && window.WPP.conn.isRegistered()")
+        except:
+            newConnected = None
+
+        if newConnected is None or newConnected == self.connected:
+            return
+        self.connected = newConnected
+
+        if not newConnected:
+            self.logger.info(f'{self.session}: Session Unpaired')
+            if self.statusFind:
+                self.statusFind('disconnectedMobile', self.session)
+
+    async def afterPageScriptInjected(self):
+        await self._afterPageScriptInjectedHost()
+        await self._afterPageScriptInjectedListener()
+        is_authenticated = await self.ThreadsafeBrowser.page_evaluate("() => typeof window.WPP !== 'undefined' &&  WPP.conn.isRegistered()")
+        self.connected = is_authenticated
+
+    def useHere(self, timeout=120):
+        return self.ThreadsafeBrowser.run_threadsafe(self.useHere_, timeout_=timeout)
+
+    def logout(self, timeout=120):
+        return self.ThreadsafeBrowser.run_threadsafe(self.logout_, timeout_=timeout)
+
+    def getMessageById(self, messageId, timeout=120):
+        return self.ThreadsafeBrowser.run_threadsafe(self.getMessageById_, messageId, timeout_=timeout)
+
+    def getMessages(self, chatId, params=None, timeout=120):
+        """
+        :param chatId:
+        :param params: (count, id, direction)
+        :return:
+        """
+        return self.ThreadsafeBrowser.run_threadsafe(self.getMessages_, chatId, params, timeout_=timeout)
+
+    def rejectCall(self, callId, timeout=120):
+        return self.ThreadsafeBrowser.run_threadsafe(self.rejectCall_, callId, timeout_=timeout)
+
+    #############################
+    async def useHere_(self):
+        return await self.ThreadsafeBrowser.page_evaluate("() => WAPI.takeOver()")
+
+    async def logout_(self):
+        return await self.ThreadsafeBrowser.page_evaluate("() => WPP.conn.logout()")
+
+    async def getMessageById_(self, messageId):
+        return await self.ThreadsafeBrowser.page_evaluate("(messageId) => WAPI.getMessageById(messageId)", messageId)
+
+    async def getMessages_(self, chatId, params=None):
+        """
+        :param chatId:
+        :param params: (count, id, direction)
+        :return:
+        """
+        if not params:
+            params = {}
+        chatId = self.valid_chatId(chatId)
+        return await self.ThreadsafeBrowser.page_evaluate("({ chatId, params }) => WAPI.getMessages(chatId, params)",
+                                                          {"chatId": chatId, "params": params})
+
+    async def rejectCall_(self, callId):
+        return await self.ThreadsafeBrowser.page_evaluate(
+            "({callId}) => WPP.call.rejectCall(callId)", callId)

WPP_Whatsapp-0.2.1/WPP_Whatsapp/api/const.py

@@ -0,0 +1,70 @@
+import logging
+
+useragentOverride = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.63 Safari/537.36'
+whatsappUrl = 'https://web.whatsapp.com'
+chromiumArgs = [
+    '--log-level=3',
+    '--start-maximized',
+    '--no-default-browser-check',
+    '--disable-site-isolation-trials',
+    '--no-experiments',
+    '--ignore-gpu-blacklist',
+    '--ignore-certificate-errors',
+    '--ignore-certificate-errors-spki-list',
+    '--disable-gpu',
+    '--disable-extensions',
+    '--disable-default-apps',
+    '--enable-features=NetworkService',
+    '--disable-setuid-sandbox',
+    '--no-sandbox',
+    # Extras
+    '--disable-webgl',
+    '--disable-infobars',
+    '--window-position=0,0',
+    '--ignore-certifcate-errors',
+    '--ignore-certifcate-errors-spki-list',
+    '--disable-threaded-animation',
+    '--disable-threaded-scrolling',
+    '--disable-in-process-stack-traces',
+    '--disable-histogram-customizer',
+    '--disable-gl-extensions',
+    '--disable-composited-antialiasing',
+    '--disable-canvas-aa',
+    '--disable-3d-apis',
+    '--disable-accelerated-2d-canvas',
+    '--disable-accelerated-jpeg-decoding',
+    '--disable-accelerated-mjpeg-decode',
+    '--disable-app-list-dismiss-on-blur',
+    '--disable-accelerated-video-decode',
+    '--disable-dev-shm-usage',
+]
+
+logging.basicConfig(level=logging.ERROR, format='%(asctime)s - %(levelname)s - %(message)s',
+                    datefmt='%d-%b-%y %H:%M:%S')
+Logger = logging.getLogger(name="WPP_Whatsapp")
+
+defaultOptions = {
+    "folderNameToken": r"E:\Projects\Python\_Libs_\tokens",
+    "headless": True,
+    "devtools": False,
+    "useChrome": True,
+    "debug": False,
+    "logQR": True,
+    "browserWS": '',
+    "browserArgs": [''],
+    "puppeteerOptions": {},
+    "disableWelcome": False,
+    "updatesLog": True,
+    "autoClose": 0,
+    "deviceSyncTimeout": 180000,
+    "createPathFileToken": True,
+    "waitForLogin": True,
+    "logger": Logger,
+    "tokenStore": 'file',
+    'whatsappVersion': '2.2326.x',
+    'deviceName': False,
+    'linkPreviewApiServers': None,
+    'disableGoogleAnalytics': True,
+    'googleAnalyticsId': None,
+    'poweredBy': 'WPPConnect',
+}

WPP_Whatsapp-0.2.1/WPP_Whatsapp/api/helpers/decorators.py

@@ -0,0 +1,21 @@
+import inspect
+from asyncio import ProactorEventLoop
+from types import FunctionType
+
+
+def async_to_sync(func: FunctionType):
+    def wrapper(self, *args, **kwargs):
+        if not inspect.isfunction(func):
+            raise Exception(f"{func} Not Function")
+        if inspect.iscoroutinefunction(func):
+            future = func(self, *args, **kwargs)
+            if inspect.iscoroutine(future):
+                self.loop: "ProactorEventLoop"
+                # try:
+                return self.loop.run_until_complete(func(self, *args, **kwargs))
+                # except RuntimeError :
+                #     return asyncio.ensure_future(future, loop=self.loop)
+
+            return future
+
+    return wrapper

WPP_Whatsapp-0.2.1/WPP_Whatsapp/api/helpers/download_file.py

@@ -0,0 +1,37 @@
+import base64
+
+import requests
+import re
+from typing import List, Union
+
+
+async def downloadFileToBase64(_path: str, _mines: List[Union[str, re.Pattern]] = []) -> Union[str, bool]:
+    if not isinstance(_mines, list):
+        print(f'set mines string array, not "{type(_mines).__name__}"')
+        return False
+
+    re_http = re.compile(r'^https?:')
+
+    if not re_http.match(_path):
+        return False
+
+    try:
+        response = requests.get(_path)
+        response.raise_for_status()
+
+        mimeType = response.headers['content-type']
+
+        if _mines:
+            isValidMime = any((m.fullmatch(mimeType) if isinstance(m, re.Pattern) else m == mimeType) for m in _mines)
+            if not isValidMime:
+                print(f'Content-Type "{mimeType}" of {_path} is not allowed')
+                return False
+
+        archive = base64.b64encode(response.content)
+        base64_content = archive.decode("utf-8")
+
+        return f'data:{mimeType};base64,{base64_content}'
+    except Exception as e:
+        print(e)
+
+    return False

WPP_Whatsapp-0.2.1/WPP_Whatsapp/api/helpers/function.py

@@ -0,0 +1,11 @@
+
+def asciiQr(code):
+    import segno
+    import io
+    qrcode = segno.make(code)
+    out = io.StringIO()
+    # qrcode.terminal(out=out, border=1, compact=True)
+    qrcode.terminal(out=out, border=1)
+    out.seek(0)
+    result = out.read()
+    return result

WPP_Whatsapp-0.2.1/WPP_Whatsapp/api/helpers/jsFunction.py

@@ -0,0 +1,115 @@
+import asyncio
+import traceback
+
+# from threading import Thread, Event
+#
+#
+# def setInterval(func, interval, *args, **kwargs):
+#     stopped = Event()
+#
+#     async def loop():
+#         while not stopped.wait(interval):
+#             await func(*args)
+#
+#     Thread(target=loop).start()
+#     return stopped
+
+
+# def setInterval(func, interval, *args, **kwargs):
+#     stopped = asyncio.Event()
+#     loop = kwargs.get('loop') or asyncio.get_event_loop()
+#
+#     async def loop_():
+#         print("__nn__")
+#         while not stopped.is_set():
+#             await func(*args)
+#             await asyncio.sleep(interval)
+#         print("finish")
+#
+#     loop. create_task(loop_())
+#     return stopped
+
+
+# async def pprint_():
+#     print("ffffffffffffff")
+#
+#
+# d = setInterval(pprint_, 5)
+#
+# async def asetInterval(func, timeout, *args):
+#     print("setInterval")
+#     while True:
+#         await asyncio.sleep(timeout / 1000)
+#         print("func")
+#         await func(*args)
+#
+#
+# def setTimeout(func, time, *args):
+#     stopped = Event()
+#
+#     def loop():
+#         while not stopped.wait((time / 1000)):
+#             func(*args)
+#             stopped.set()
+#
+#     Thread(target=loop).start()
+#     return stopped
+#
+#
+# def clearInterval(Interval):
+#     try:
+#         if Interval:
+#             Interval.set()
+#             print("Interval", Interval.is_set())
+#             # Interval.clear()
+#     except:
+#         traceback.print_exc()
+#
+#
+# async def print_i(i):
+#     print(i + 1, "print_i")
+#     await asyncio.sleep(1)
+#     print(i + 2, "print_i")
+
+
+# async def stop_All():
+#     clearInterval(intr)
+#     clearInterval(intr2)
+
+
+# intr = setInterval(print_i, 5, 1)
+# intr2 = setInterval(stop_All, 50, )
+
+
+from typing import Dict
+
+
+class EventEmitter:
+
+    def __init__(self):
+        self._callbacks: Dict[str, callable] = {}
+
+    def on(self, event_name, function):
+        self._callbacks[event_name] = self._callbacks.get(event_name, []) + [function]
+        return function
+
+    def emit(self, event_name, *args, **kwargs):
+        [function(*args, **kwargs) for function in self._callbacks.get(event_name, [])]
+
+    def off(self, event_name, function):
+        self._callbacks.get(event_name, []).remove(function)
+
+
+def setInterval(loop, func, interval, *args, **kwargs):
+    stopped = asyncio.Event()
+
+    async def loop_():
+        while not stopped.is_set():
+            if asyncio.iscoroutinefunction(func):
+                await func(*args, **kwargs)
+            else:
+                func(*args, **kwargs)
+            await asyncio.sleep(interval)
+
+    loop.create_task(loop_())
+    return stopped

WPP_Whatsapp-0.2.1/WPP_Whatsapp/api/helpers/scrap-img.py

@@ -0,0 +1 @@
+