webscout 6.5__py3-none-any.whl → 6.7__py3-none-any.whl

{webscout-6.5.dist-info → webscout-6.7.dist-info}/RECORD

@@ -4,23 +4,23 @@ webscout/AIutel.py,sha256=gsV08e3F6aH4j7wH5V9X3N9T5Ea5MAIQq4M47vNofuI,12020
 webscout/Bard.py,sha256=CmDhKC67Ki2xA8Rkme6EC-gLmq3PhAAAGd5tcpJ0KJo,13234
 webscout/DWEBS.py,sha256=GsKbaVgcxDC5eHtNjxr6r5uk3_8NhtxVG2dqJJVGqaI,18543
 webscout/LLM.py,sha256=essCz1nakJfmoKLJFguyJnba0HR4AfY6BVU0CEGDCcQ,16336
-webscout/__init__.py,sha256=IMDl0kRpLtNMi1HOW6HXoBp0CevEpLPkol8GJhorMno,657
+webscout/__init__.py,sha256=eMlqim4Cnc-BLcegMaTtDb2NGt3n48E331IqLx125Mk,864
 webscout/__main__.py,sha256=pBm2E3ZZiMcCH37b1YCz7qKdKdX_i_S5En6fZDeJKFw,103
-webscout/cli.py,sha256=bLaSGs24wxfZlK37_WPPr1jjfbv50nfbxkeSkED0jX0,12456
-webscout/conversation.py,sha256=fWWrBwhZztasvW7aLSLsTLpHzuTeuV4jGXPWzXukNj8,8088
-webscout/exceptions.py,sha256=qdyWoLV1nEPffb5vz9cu9EfBwIwZ4nmcCinqeJDBWTo,5182
-webscout/optimizers.py,sha256=gMZqYA7Slw7F9e_Gp4umkpMYKtdVFJBn-yDrlFYP4Wo,9168
+webscout/cli.py,sha256=3AG2adVRirqKQMvXX312nswNBtRpmW9-2C16eAhfRd4,11994
+webscout/conversation.py,sha256=LMZWJVnyc1P5GLAzCLKvw6UU07nD3wA44l9sKh3nu8k,8763
+webscout/exceptions.py,sha256=10OLw5gFpfyGSSfAMRWT2OYCkdiEJR2byRv74kftAhc,11383
+webscout/optimizers.py,sha256=ALT4SeO_s_JV6yWG7XJJ3aZIoEiTN1PIaCZJtnGdxXs,10749
 webscout/prompt_manager.py,sha256=Jc0demWN6M6QcwRp14aHZR05r_PVPOaG8PnQkO7pDZ4,9806
 webscout/tempid.py,sha256=7ZTN2eAYqUO2deSdzzhZfgDRxE65OOhGuTBD7f8bTCM,5004
-webscout/update_checker.py,sha256=mw4XOEhGpe68nXuo6yXIQqA_Vt5sJhY_-5iUWsiF0oo,4179
+webscout/update_checker.py,sha256=mLFD_OYjtEdUvXUiNt8wSbspmkFRmNlULf5sVyVZi60,5129
 webscout/utils.py,sha256=LVW7U0XcGYqigqxV6D5YXeGMrc_mt7PnNG_YnKf9bBM,3059
-webscout/version.py,sha256=K8NenkGw5y4bDvKGg-xeUewcUgMDcrcEPUuhVqQbUw8,44
-webscout/webscout_search.py,sha256=HHdO9XLToC_9nIMM_SaTOKKfzdhrKjb7o8Zi3ZD1O7Y,44744
+webscout/version.py,sha256=2LxYXNP6zbhOX47Xl9v4Dpp05K2LUel-8-Ayyzbaw-c,44
+webscout/webscout_search.py,sha256=kFdcr3-2LaksTbFy9Pmrs_Gfi9XwtfxKKk5_H0hBa80,44748
 webscout/webscout_search_async.py,sha256=2-RCa9Deahhw3Bti78kXfVaX8y3Aygy4L7HeCaITk9M,14519
 webscout/Extra/__init__.py,sha256=FbDnwI3zZdoQFosA5Q2bIYpJlHUKFWiFmFKvnk9xWKY,153
 webscout/Extra/autollama.py,sha256=Mcj7YT8mYL5J7Rg_Wmi3Ppcfh1WK6UWcrbUZySetwuU,8198
 webscout/Extra/gguf.py,sha256=u_HQ00hiKCcF4GiVabUnFTXEPTmUpa2ADjBNHxtR7bw,16053
-webscout/Extra/weather.py,sha256=q-h5UXL2XEBEgoqvEeLRut-ThieNzH_GNfOEIeghKLM,6000
+webscout/Extra/weather.py,sha256=XVi9fb7KZdUNaZjGzCHo8UIkK4v8-rWVfYuDiFbN8WY,5960
 webscout/Extra/weather_ascii.py,sha256=AsSJT6OCpg9vxzW5h7h0s0PEMq_m_ixvcc7VDtNERdw,793
 webscout/Extra/YTToolkit/YTdownloader.py,sha256=NfbukCKdyWycl9RzJBXzqSPKW6FwWe7EQxhfLf_dJj8,34793
 webscout/Extra/YTToolkit/__init__.py,sha256=Wn1K-f6OjZ4GuWvL3FTM4zlTaF3xdb4v_K60YDxKdXg,75
@@ -38,7 +38,7 @@ webscout/Extra/YTToolkit/ytapi/stream.py,sha256=7VscCVBwLx_Lz8qFOQdKCSyeAiv_A3aU
 webscout/Extra/YTToolkit/ytapi/utils.py,sha256=ENjmAjlOTLib0ANxysuSb2kgDl3NtDTvW60b18H-Rzc,1966
 webscout/Extra/YTToolkit/ytapi/video.py,sha256=OzX1XJJ4qRjti0VOlrsOC8kDvZihMVgUFTyrT-AYYms,3877
 webscout/Extra/autocoder/__init__.py,sha256=jcDJEXVde_ATffVNjV4vQMvvWH0UDW-HRz5OKNoZ7cg,218
-webscout/Extra/autocoder/autocoder_utiles.py,sha256=hGAnOWJISuHm0UOKSWwre9_wCqJqDGYVbvyKJ6GrnuQ,4268
+webscout/Extra/autocoder/autocoder_utiles.py,sha256=sFDvbJugd4emgNPr8CQB9IhdZqz4w8TOMZddHyEjNyI,6210
 webscout/Extra/autocoder/rawdog.py,sha256=o2lMY4Fwvl3GawBzwGXuqu-5dPFzDyX3ZZL1xmQV7Ls,25806
 webscout/Extra/markdownlite/__init__.py,sha256=IJQ5SOs4nxmAdhZk8JylNdD6SsKJPZgvnzGqu6v4qWc,32339
 webscout/Litlogger/__init__.py,sha256=Q5FPfGKktfFyvqa6kMbye9LLzuy6VXGOgE3Q-uBGD2E,23928
@@ -51,7 +51,7 @@ webscout/Local/thread.py,sha256=ctnoJtkOpKbpdlqCjsnyM2sI-3_AKg9PzNwS3QAIifQ,2360
 webscout/Local/ui.py,sha256=FhqBcC7SVHwRfvrnTduoa7gpQNWYzrSc7OGm89ErNPY,15064
 webscout/Local/utils.py,sha256=kYXfR9h4JFojkiKQhF1XHclqX0vB0qPKOkfYKjrgwuc,13216
 webscout/Provider/AI21.py,sha256=JBh-xnspxTZNMcl-Gd0Cgseqht9gTM64TUv9I4Imc9k,6218
-webscout/Provider/Amigo.py,sha256=bs5M-HzfKIcdCfS_50JMsX5DpS0eBWwtHNyOrTR7lAo,12304
+webscout/Provider/Amigo.py,sha256=LkZuvFUwkmdzgMhUEMYvXKpNpLstjznRMe-CQydYO7g,11637
 webscout/Provider/Andi.py,sha256=-vqXWlJcHzhfZ-iW4qJy9yxzctPKp2RdmdW02hf4XLs,8863
 webscout/Provider/Bing.py,sha256=zxIzq7dlqaLskx9LsYppbMJuwfGtYid3Uh0gIhZ0hps,9001
 webscout/Provider/Blackboxai.py,sha256=KntNTWHHEmXegKFxm79_2tX_FLQF-_7xssrB6T0nCgM,8841
@@ -69,23 +69,23 @@ webscout/Provider/Free2GPT.py,sha256=Lf8dd9iacry_GRr6CT86Cjcp-oNzLyw1O_TWIPDFDxk
 webscout/Provider/GPTWeb.py,sha256=xh_mnBko6RDyz2v3KhMux-yIipipkZfVVVoUJWkbzcQ,7466
 webscout/Provider/Gemini.py,sha256=Vg2MLqQ_qxHkcN7Zikife1dyVK-y94ik8y6MAu-VzUI,7801
 webscout/Provider/Groq.py,sha256=iqyewnxWwN7fMG-dqAR_SyUqImfyZS880lO5iaXso9c,28636
+webscout/Provider/Jadve.py,sha256=_8qlC0oWjGlJAUL6yH__cd6NSGkT0mcLdEZHixFlp-M,9394
 webscout/Provider/Koboldai.py,sha256=gpRgyDe4OQWwNqT7MWnNrJx4dnFmCW23KUx0Ezjgchk,15185
 webscout/Provider/Llama.py,sha256=N01p3ZVD1HgRnNNxhjRhBVD4m_qiextdyF1KDfJlqbE,7703
 webscout/Provider/Llama3.py,sha256=fU1iyKflFHDeSqa32M6UE2JtADZB0B7rcG5HYj5MWSQ,7581
 webscout/Provider/Marcus.py,sha256=6LvBYnAcbwVYiXoQ8ZrprefJ6zS2KdveiEZauClNtSE,5045
+webscout/Provider/Netwrck.py,sha256=TtW-W4oSGwf8JiMBXN6EBttQMA0tMaYvuYnRs0YNI68,9482
 webscout/Provider/NinjaChat.py,sha256=tMja5xItus6WoKJm_fhILLoGyPdplikqr-nxtuUziNU,8617
 webscout/Provider/OLLAMA.py,sha256=RQXJt-PJYnA15_IXhUy4mM9qwm4PcBMfINaZm2KG6zE,7018
-webscout/Provider/Openai.py,sha256=32uxZmZOovzshMQmqDcJ39If7N_UW4B3EeYmaxP_GwE,19983
-webscout/Provider/PI.py,sha256=dMUpd1hLg72W7rnsza3k9QHBLmAi3GHSPRCkzmH-Ags,12860
-webscout/Provider/Perplexity.py,sha256=BC4ZbVAjumNhw4_wNbs1Y4lwshEpJF5lanTmSqkXVG8,20476
+webscout/Provider/Openai.py,sha256=mpJ9VgIyvW6uo0-jIcx5Qcz4PIUAj3xVLOgKrB1z9pU,20074
+webscout/Provider/PI.py,sha256=Z2yXXCv84AUbvNNaBQHkJ-Hgp-oc8sPfcvWytYwISVc,12781
 webscout/Provider/Phind.py,sha256=NA_b3B4h-kutX6wdoEg4THPfZggl2UeXPbramzZ6oiU,19297
-webscout/Provider/PizzaGPT.py,sha256=tEuEJAGbv-mTd479i3EgaqHd4NwgkrmMW0fpSsGm_N0,7207
+webscout/Provider/PizzaGPT.py,sha256=GkyvWvs_aIcXSpM-j-CfH7Jsft2vU1IUxXmyZ-Z23kI,7120
 webscout/Provider/RUBIKSAI.py,sha256=fHCOAFWGXIESA05Bmuqtx6ZChnWomHOMwndfTLv1Hg8,8517
 webscout/Provider/Reka.py,sha256=dWw4vX91nJhAn-X1SXK72gttRaTqWNGUBFaeRJobTJg,8519
-webscout/Provider/RoboCoders.py,sha256=vH1B0cKzQW6fU1TWwpUlnuQFW3uirzIWj0WIpiPal1s,7957
-webscout/Provider/TeachAnything.py,sha256=u5HxlVdOnRWXzA-cRSRhhdnvdsfafJ_4wr9qKIuW45s,6743
-webscout/Provider/Youchat.py,sha256=G6I4TqjZuX3refFF3SkOgl_YXY57hjsMg_wRjPgqWIE,9014
-webscout/Provider/__init__.py,sha256=lPzcVlyGtXFb9WJWOv0-jLdHRNXqIANpjqx-8SAGTYU,3191
+webscout/Provider/TeachAnything.py,sha256=6scp1tzcc5z_TKUALArQ4APCNElHJ7SzsJoiB71o0V0,7169
+webscout/Provider/Youchat.py,sha256=hwm16gmyvMrRseFHl7nrcaHzGlY8BUx3y0KD-YQjTnc,10082
+webscout/Provider/__init__.py,sha256=rns4O8C6Thft04CCq9OgAGl1GE8n-ofsvjcyt8CfGfc,2715
 webscout/Provider/ai4chat.py,sha256=av96iS4QPt9IzhcswowmDY2F8IUSLl1YVHZ4bAbfO-s,8140
 webscout/Provider/aimathgpt.py,sha256=BdXNxEHQP11p6m0wl2Q-uben46A6lMKOg89utV1S7aI,7320
 webscout/Provider/askmyai.py,sha256=XDxLQfIztI-jwergalUfNiMOwNEw62jGTN4yTlar8Po,5895
@@ -93,11 +93,9 @@ webscout/Provider/bagoodex.py,sha256=OdYIyvypX-Vkok9zAr6F5NwFQx_z0bKhiw8U4tTFw5o
 webscout/Provider/cerebras.py,sha256=cyUIgGdVMAmBgTifwuPW-XGC2SKGL2CbTKxY8al9ji4,7986
 webscout/Provider/cleeai.py,sha256=tXs_XuYZ2ZGmSOSTS0yJ59qbvFCJusE7yZkIqALwUbE,8064
 webscout/Provider/elmo.py,sha256=6C-j8xLfgyMjmv8jdjey0BPzl_UwEFpMEbBtYobfPd0,9387
-webscout/Provider/felo_search.py,sha256=q_Mc4SgSnkCm5vu-CMmn9kVO3k0YCZqq_uMUrVUXInU,6888
 webscout/Provider/gaurish.py,sha256=yKV4MvOvjMEsXY2fQXDc0YHyFBtW2sh-pA4YNdY--wE,8472
 webscout/Provider/geminiapi.py,sha256=c2zvwqkRgscI8vU1FU4qb_4fPe374LIQJ_uHNM9lmF8,8297
 webscout/Provider/geminiprorealtime.py,sha256=unQRqHkDt_gkZ_Ls0qBb73d6YTtqYwd1uhYW0RrXKI0,5845
-webscout/Provider/genspark.py,sha256=zKg0nWNzi38Mai_ShBISnmRSpfrBXAIZcTYyf8iX9h8,8764
 webscout/Provider/julius.py,sha256=unD3UUnW8-Bie4o0__Vn7cXfqnaVvlE3MWI-LYGb5VE,8576
 webscout/Provider/koala.py,sha256=qBtqjTvhoMQdDE8qUH0XuNa_x2bic77d7CUjIVboask,10106
 webscout/Provider/learnfastai.py,sha256=xANWSHF3e6kTKgwbAHYdjNWIwYvr5Bin0NDENmJvruE,9763
@@ -105,19 +103,19 @@ webscout/Provider/lepton.py,sha256=4RiQ4YNJljX558yhSUqws6pf1Yhf7pWIesa4SRQCry8,7
 webscout/Provider/llama3mitril.py,sha256=3Ur3GMkmSSTmyxJh1u9fF0xlZ7ssFF6Jxuoi587N1lw,6501
 webscout/Provider/llamatutor.py,sha256=DijA4Y1CVDz-Ks8pACTSb6hnOxdQD2IHw-_ztRqhyPQ,8871
 webscout/Provider/llmchat.py,sha256=gr7ewEPWWIfjhmpQXTOZJxQffol8MA1yWAIXdG3VZZo,7944
-webscout/Provider/meta.py,sha256=N1Ia1iDADfk1QJUHb10Vq5UvObiybQsi5QlUoNVaY-M,30456
+webscout/Provider/meta.py,sha256=3LkGoiGtorc28aURqIpdbMdrDt7QfdARpl1Fp7XNSIg,30460
 webscout/Provider/mhystical.py,sha256=W3j28XOnVGlRPCSYrjA5N7okYEdTVeOw41HdocfvzqE,6555
-webscout/Provider/perplexitylabs.py,sha256=3_qnAoh0nsp6uhqFqzwUyXBezAzmRFs4YSRxVIokYF8,9651
-webscout/Provider/prefind.py,sha256=msw_kXO59Xz-xG5f72O3WIww-HVyUAj-WpByeLiCB1U,9306
-webscout/Provider/promptrefine.py,sha256=NbRdvCsiiLIDwU39wzxch5yGwmLvbauljAl9vC73nR4,7714
-webscout/Provider/talkai.py,sha256=UZNiuQm5IPX_VFPOIVc1SJNPTKAcbvaOVO9fsVDVXNY,7434
-webscout/Provider/turboseek.py,sha256=yDOZcS3UqHcas_pH1AcB-XLD6C2FRzZxLp8rJOhUZGQ,8521
-webscout/Provider/tutorai.py,sha256=ov-gRPAh22n8v7TWjeLdPnuHgCcaAsdpc2IfxfuSIEk,14716
-webscout/Provider/twitterclone.py,sha256=SsLFZ-PansLdhw0HHBrqZtrjI4ItiHvoHfQBroXHORw,9509
-webscout/Provider/typegpt.py,sha256=6_i06EYXlJyqIMlZ_NwG4w9D96C6yfIMvAfHW-R9P6Q,12732
-webscout/Provider/upstage.py,sha256=rdH94hIwR98HKfar576WzVmgdB1DU2H8qaChUmJFtPc,9237
-webscout/Provider/x0gpt.py,sha256=Z8U4MQIRfhHpdarHO6_BZ27veXMDEAneguJ7uFSD_HU,6478
-webscout/Provider/yep.py,sha256=ge7a3cK02G6tbT0_q9glH7ujCx3QlgrqwBuHasQVYfQ,20581
+webscout/Provider/multichat.py,sha256=c1TFCGv3Ds06mO5eYl_6YmUjGkg_dkqh2weQpYYsc08,8415
+webscout/Provider/promptrefine.py,sha256=W0Ka59yRRKCOBXfF_hF-iF30F0AR45OPxgCCZ6mZzuA,7722
+webscout/Provider/talkai.py,sha256=FHBZzBdHrOVn41nkhhJmjhHuR1NKTOBE7lGgYDV-0dk,7598
+webscout/Provider/turboseek.py,sha256=uEoL5eJFvnpDCymTufrC8O9Ni3i8acb0GBy4JweFeIE,8474
+webscout/Provider/tutorai.py,sha256=qBwo53bNtCumFonF43m0RCOQx6dU6t869Cnhw3H6qSM,11204
+webscout/Provider/typegpt.py,sha256=TMNu1h8pyiTqynJoZXi150TjGzGkyZzYGvFKiXnZM3g,12700
+webscout/Provider/x0gpt.py,sha256=eKDEbUIkY1Cc8mCad-CFA4ZgBXOmR7T7rKf89lh16-8,9383
+webscout/Provider/yep.py,sha256=uor5RXrEjdoTsEvAROnAa6cZnW2Zlpm382AoltGkvRg,9926
+webscout/Provider/AISEARCH/__init__.py,sha256=V9Su6olCAu7JUy1NK_ia198_7YOFfYvUb6u0XGvLQRg,47
+webscout/Provider/AISEARCH/felo_search.py,sha256=q_Mc4SgSnkCm5vu-CMmn9kVO3k0YCZqq_uMUrVUXInU,6888
+webscout/Provider/AISEARCH/ooai.py,sha256=Ubi8lruI4vBcxQQUO3_qufqOs-7qH34hGNOSk47vuFU,5722
 webscout/Provider/TTI/__init__.py,sha256=9Hu_y-z6Ev2SQL5-IF_B4UDetoOl7hVclka1RatQ6_M,225
 webscout/Provider/TTI/AiForce/__init__.py,sha256=Ukeas_Ny6VQBwCDEWuBMlWbeTki82ir1MtZdR2vNJPc,663
 webscout/Provider/TTI/AiForce/async_aiforce.py,sha256=7Gpgu__TPNLZwxayqfOOkRcKpIdAfE1x8wE-RoylEAY,9647
@@ -156,24 +154,44 @@ webscout/Provider/TTS/streamElements.py,sha256=0cfayE1eQYQj4ILF9tmHdodIcw9WknTKs
 webscout/Provider/TTS/utils.py,sha256=-2sXcGG1lDBIr32fssI1Tf9yxl7gMWZRM0xzUFebeko,10599
 webscout/Provider/TTS/voicepod.py,sha256=cMF7k88cP-RMqkqcoT8cu1o-eehxd2tqiq8laJeuMJw,4227
 webscout/litagent/__init__.py,sha256=V-hXEmMp3UH1qKmJDtL0j6_mazmbyyRrIqKqt__oIRw,6091
-webscout/litprinter/__init__.py,sha256=eMGF91G3l8qMHDwwCnL-8-fGGGMLTSsdd9GfIRviJCA,31565
-webscout/scout/__init__.py,sha256=fhN3P47AmrK2dINYc_lXqPbrITtMO5Gnnqs5PmoZqLY,241
+webscout/litprinter/__init__.py,sha256=3Hdtj0-YSdwNqxc_Uc_yZIv7gnsap4e4dvqni4CA9oY,28821
+webscout/litprinter/colors.py,sha256=5L_WmYFcp2JoX1rCS4GvFCNCOlj2EhEJRGWvqvs8M54,1247
+webscout/scout/__init__.py,sha256=C-uYGqVR7iiScetSxUTHc76i0OLQnWJO7WFTfhgafW4,325
 webscout/scout/core.py,sha256=Joiw1RTPse2VQOjF5y6Uksa_ixsUSIO58RLWnyx6gbU,28761
-webscout/scout/element.py,sha256=PZ-Hd5eyhUtqfPNY5wAPm-gNLOdPD3_y0H94mFrqBw4,14787
+webscout/scout/element.py,sha256=DakYPD49kIqXI358XEKeJSQTW802h4B2bP2z_FE5M3Q,14861
 webscout/scout/utils.py,sha256=a9QJnsJ6LyYRRrjJYGUrvFfkBsynTcIgXR86t4tgaM4,979
+webscout/scout/core/__init__.py,sha256=ncF9MkM3iO1B2Ew_nOwzLQeeJ1xkCdoJ77CCZADD974,296
+webscout/scout/core/crawler.py,sha256=VNUSEhJx8gLzYDgK0aXKYqXNLnbI-OFroLUlnQ9WYEw,5144
+webscout/scout/core/scout.py,sha256=LZcC7bjis8BWqSwhm6Q6wKaMvrDEnzbqa91wlfeqpG4,19300
+webscout/scout/core/search_result.py,sha256=rx0lz0qd6Rvaj79885yKQQXR_0cQrPtoJdzVX5J0msw,2962
+webscout/scout/core/text_analyzer.py,sha256=gm30VZAnAH5DPgt6OhYd4bOriK-sSwgtEBqrx4NWm6o,1846
+webscout/scout/core/text_utils.py,sha256=N44y2zeUt6MSUf3jlG4TCUdOF9DgkcL4UILdWrpRUeQ,10823
+webscout/scout/core/web_analyzer.py,sha256=iPlt1GIU-NlUR-ccIXguLYQgE1IGu4S2kjEhT87ofZc,1674
 webscout/scout/parsers/__init__.py,sha256=a0gysttcAnIxfY8UBbkNJdmMHEhfeI9VmfnQGZVYKPk,1762
 webscout/scout/parsers/html5lib_parser.py,sha256=VRCQIDh7Z9XbS8-zSOsmRtR2Oyx_DEz85hjRvabBQ2Y,5627
 webscout/scout/parsers/html_parser.py,sha256=pHCKl-n_9uNt2ld09nY6hiyFuCi4azT7Be8Rzlo1GQQ,6820
 webscout/scout/parsers/lxml_parser.py,sha256=fDaxFuBSlU9x5hH5nDj5BHd72r9XHZ24Z5lt6FYPt_8,6053
 webscout/swiftcli/__init__.py,sha256=Yr_bsL1E3FaUh-xqWK_2ecG91IC2mSiP7eBa3en0mHc,27758
 webscout/zeroart/__init__.py,sha256=WKB5gM0VY-trL0rWmMwYiStFyoMGe9ivx0DQ-IJe0W8,1308
-webscout/zeroart/base.py,sha256=7Z5I5qFm11g5R8PktltDze8zF2VAIXswNrb5Z-jlRvw,1821
-webscout/zeroart/effects.py,sha256=_UWmnxlTlf1gnT90nAXmgj-0j7_GAK7yX5KTNj34728,2932
-webscout/zeroart/fonts.py,sha256=nBwIMxuXTJiZq2C654tPEiHt0KwyuO6iYnuBjQIf_O0,24842
+webscout/zeroart/base.py,sha256=X7bjkpD9iaP6IS6gHS7A12j8jRHbxzpJZb3ZJyhdxD0,1923
+webscout/zeroart/effects.py,sha256=aSuoT68sOBvzuCM54mOu8LO6VhKaIq6SbYpcVdF1Jm0,2933
+webscout/zeroart/fonts.py,sha256=VrmHowbkIvjqnanI6MbUxNji2cYhwzEaXgm-DxXec3k,24843
 webscout/zerodir/__init__.py,sha256=NHDON7WoN26G80uRXxPHH3jeTQhvz25Zx0yA7qq81fw,8396
-webscout-6.5.dist-info/LICENSE.md,sha256=5mkWS6cgjGxJClmN7n--h0beF3uFAOV_Ngr1YTK33Tk,9203
-webscout-6.5.dist-info/METADATA,sha256=phd5n2QatIQPBHY2hnEiY3z7LTiq0kkfSiRA-6PBDlI,46144
-webscout-6.5.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-webscout-6.5.dist-info/entry_points.txt,sha256=Hh4YIIjvkqB9SVxZ2ri4DZUkgEu_WF_5_r_nZDIvfG8,73
-webscout-6.5.dist-info/top_level.txt,sha256=nYIw7OKBQDr_Z33IzZUKidRD3zQEo8jOJYkMVMeN334,9
-webscout-6.5.dist-info/RECORD,,
+webstoken/__init__.py,sha256=I38YnMUFGT30I-6754-tIUmFnTZnWoVA8AP1-FpD-fU,774
+webstoken/classifier.py,sha256=CApGnXyPbaS87SN9_MFb4XTh24UTKdaXekR6JcWAFJo,7463
+webstoken/keywords.py,sha256=6PSukt3omZWe5T3Gt_GAW1ypol2Oylk2AwfXrLCLVUU,8262
+webstoken/language.py,sha256=mRAIujNI27urD5XHYIixLdBGazpQYDMmErw0gKb4ivU,5936
+webstoken/ner.py,sha256=mOon6O9XGs0gsI2VidLxLrL3qTW6lwqzLEa3a1OwVyM,6075
+webstoken/normalizer.py,sha256=-raK5_VMyyeXxEYF7panghYejeQkhKJqxqdhDCX1zwI,1110
+webstoken/processor.py,sha256=szBNJNFjAjSOHoH4Q2h_MugE_AOnj-QoZwS83sn68Gg,2369
+webstoken/sentiment.py,sha256=Bivwm9Wmo2GMXvKYxPxd1vrnyDwDywyjxmOIe6jP6NM,7996
+webstoken/stemmer.py,sha256=AYg1frOaS2CWF-KvFwh3_s-VMZUa0olM7CN1UaEpc-8,2551
+webstoken/t.py,sha256=jrgacr0xK8Xbc9BZNtMknZv2xQagg9eMO3MXwCvIIFE,2558
+webstoken/tagger.py,sha256=RgDxPw0E6VgeXTrAFnnOb4X2J2Hu3snafr-MJeWtHlc,2246
+webstoken/tokenizer.py,sha256=RAaihP3Yq4OFHcXrTNUGBDLbq1-ti_lVUEw0CIPPCww,5858
+webscout-6.7.dist-info/LICENSE.md,sha256=5mkWS6cgjGxJClmN7n--h0beF3uFAOV_Ngr1YTK33Tk,9203
+webscout-6.7.dist-info/METADATA,sha256=NaQoy4zNP_3FPsgqqCkP1FzMoy5KsUS9vb5TjSP38Sc,40718
+webscout-6.7.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+webscout-6.7.dist-info/entry_points.txt,sha256=7thMsVUoHiXGoIH1NeoocKpxlszWflNsNyrnDqGzvO0,70
+webscout-6.7.dist-info/top_level.txt,sha256=KQtbgkA3gxcsADB0hIIx-heydmEYXpAY7xn3LjwDx0E,19
+webscout-6.7.dist-info/RECORD,,

{webscout-6.5.dist-info → webscout-6.7.dist-info}/entry_points.txt

@@ -1,3 +1,3 @@
 [console_scripts]
 WEBS = webscout.cli:cli
-webscout = webscout.webai:main
+webscout = webscout.cli:cli

webscout-6.7.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+webscout
+webstoken

webstoken/__init__.py

@@ -0,0 +1,30 @@
+"""
+Webstoken - A pure Python NLP toolkit for text processing
+"""
+
+from .tokenizer import SentenceTokenizer, WordTokenizer
+from .tagger import POSTagger
+from .stemmer import Stemmer
+from .normalizer import TextNormalizer
+from .processor import process_text
+from .ner import NamedEntityRecognizer
+from .classifier import TextClassifier, TopicClassifier
+from .language import LanguageDetector
+from .sentiment import SentimentAnalyzer
+from .keywords import KeywordExtractor
+
+__version__ = '0.1.0'
+__all__ = [
+    'SentenceTokenizer',
+    'WordTokenizer',
+    'POSTagger',
+    'Stemmer',
+    'TextNormalizer',
+    'process_text',
+    'NamedEntityRecognizer',
+    'TextClassifier',
+    'TopicClassifier',
+    'LanguageDetector',
+    'SentimentAnalyzer',
+    'KeywordExtractor'
+]

webstoken/classifier.py

@@ -0,0 +1,189 @@
+"""
+Text classification module using rule-based and statistical approaches.
+"""
+
+from typing import Dict, List, Set, Tuple
+from collections import Counter
+import math
+import re
+
+from .normalizer import TextNormalizer
+from .tokenizer import WordTokenizer
+
+
+class TextClassifier:
+    """Simple text classifier using TF-IDF and cosine similarity."""
+    
+    def __init__(self):
+        self.word_tokenizer = WordTokenizer()
+        self.normalizer = TextNormalizer()
+        self.documents: Dict[str, List[str]] = {}  # category -> list of documents
+        self.vocabulary: Set[str] = set()
+        self.idf_scores: Dict[str, float] = {}
+        self.category_vectors: Dict[str, Dict[str, float]] = {}
+    
+    def train(self, documents: Dict[str, List[str]]) -> None:
+        """
+        Train the classifier on labeled documents.
+        
+        Args:
+            documents: Dict mapping categories to lists of documents
+        """
+        self.documents = documents
+        
+        # Build vocabulary and document frequencies
+        doc_frequencies: Dict[str, int] = Counter()
+        total_docs = sum(len(docs) for docs in documents.values())
+        
+        for category, docs in documents.items():
+            for doc in docs:
+                # Normalize and tokenize
+                doc = self.normalizer.normalize(doc)
+                tokens = self.word_tokenizer.tokenize(doc)
+                
+                # Update vocabulary and document frequencies
+                unique_tokens = set(tokens)
+                self.vocabulary.update(unique_tokens)
+                doc_frequencies.update(unique_tokens)
+        
+        # Calculate IDF scores
+        self.idf_scores = {
+            word: math.log(total_docs / (freq + 1))
+            for word, freq in doc_frequencies.items()
+        }
+        
+        # Calculate TF-IDF vectors for each category
+        for category, docs in documents.items():
+            category_vector: Dict[str, float] = {word: 0.0 for word in self.vocabulary}
+            
+            for doc in docs:
+                # Get term frequencies
+                doc = self.normalizer.normalize(doc)
+                tokens = self.word_tokenizer.tokenize(doc)
+                term_freqs = Counter(tokens)
+                
+                # Update category vector with TF-IDF scores
+                for word, tf in term_freqs.items():
+                    if word in self.idf_scores:
+                        category_vector[word] += tf * self.idf_scores[word]
+            
+            # Average the scores
+            for word in category_vector:
+                category_vector[word] /= len(docs)
+            
+            self.category_vectors[category] = category_vector
+    
+    def _calculate_vector(self, text: str) -> Dict[str, float]:
+        """Calculate TF-IDF vector for input text."""
+        # Normalize and tokenize
+        text = self.normalizer.normalize(text)
+        tokens = self.word_tokenizer.tokenize(text)
+        term_freqs = Counter(tokens)
+        
+        # Calculate TF-IDF scores
+        vector = {word: 0.0 for word in self.vocabulary}
+        for word, tf in term_freqs.items():
+            if word in self.idf_scores:
+                vector[word] = tf * self.idf_scores[word]
+        
+        return vector
+    
+    def _cosine_similarity(self, vec1: Dict[str, float], vec2: Dict[str, float]) -> float:
+        """Calculate cosine similarity between two vectors."""
+        dot_product = sum(vec1[word] * vec2[word] for word in vec1)
+        norm1 = math.sqrt(sum(score * score for score in vec1.values()))
+        norm2 = math.sqrt(sum(score * score for score in vec2.values()))
+        
+        if norm1 == 0 or norm2 == 0:
+            return 0.0
+        return dot_product / (norm1 * norm2)
+    
+    def classify(self, text: str) -> List[Tuple[str, float]]:
+        """
+        Classify text into categories with confidence scores.
+        
+        Returns:
+            List of (category, confidence) tuples, sorted by confidence
+        """
+        if not self.category_vectors:
+            raise ValueError("Classifier must be trained before classification")
+        
+        # Calculate vector for input text
+        text_vector = self._calculate_vector(text)
+        
+        # Calculate similarity with each category
+        similarities = [
+            (category, self._cosine_similarity(text_vector, category_vec))
+            for category, category_vec in self.category_vectors.items()
+        ]
+        
+        # Sort by similarity score
+        return sorted(similarities, key=lambda x: x[1], reverse=True)
+
+
+class TopicClassifier:
+    """Rule-based topic classifier using keyword matching."""
+    
+    def __init__(self):
+        # Define topic keywords
+        self.topic_keywords = {
+            'TECHNOLOGY': {
+                'computer', 'software', 'hardware', 'internet', 'programming',
+                'digital', 'data', 'algorithm', 'code', 'web', 'app', 'mobile',
+                'cyber', 'robot', 'ai', 'artificial intelligence', 'machine learning'
+            },
+            'SCIENCE': {
+                'research', 'experiment', 'laboratory', 'scientific', 'physics',
+                'chemistry', 'biology', 'mathematics', 'theory', 'hypothesis',
+                'study', 'discovery', 'innovation', 'analysis', 'observation'
+            },
+            'BUSINESS': {
+                'company', 'market', 'finance', 'investment', 'stock', 'trade',
+                'economy', 'business', 'corporate', 'startup', 'entrepreneur',
+                'profit', 'revenue', 'management', 'strategy', 'commercial'
+            },
+            'POLITICS': {
+                'government', 'policy', 'election', 'political', 'democracy',
+                'parliament', 'congress', 'law', 'legislation', 'party',
+                'vote', 'campaign', 'president', 'minister', 'diplomatic'
+            },
+            'SPORTS': {
+                'game', 'team', 'player', 'competition', 'tournament',
+                'championship', 'score', 'match', 'athlete', 'sport',
+                'win', 'lose', 'victory', 'defeat', 'coach', 'training'
+            },
+            'ENTERTAINMENT': {
+                'movie', 'film', 'music', 'song', 'concert', 'actor',
+                'actress', 'celebrity', 'show', 'performance', 'art',
+                'entertainment', 'theater', 'dance', 'festival', 'media'
+            }
+        }
+        
+        # Compile regex patterns for each topic
+        self.topic_patterns = {
+            topic: re.compile(r'\b(' + '|'.join(re.escape(kw) for kw in keywords) + r')\b', re.IGNORECASE)
+            for topic, keywords in self.topic_keywords.items()
+        }
+    
+    def classify(self, text: str) -> List[Tuple[str, float]]:
+        """
+        Classify text into topics with confidence scores.
+        
+        Returns:
+            List of (topic, confidence) tuples, sorted by confidence
+        """
+        # Count keyword matches for each topic
+        topic_matches = {
+            topic: len(pattern.findall(text))
+            for topic, pattern in self.topic_patterns.items()
+        }
+        
+        # Calculate confidence scores
+        total_matches = sum(topic_matches.values()) or 1  # Avoid division by zero
+        topic_scores = [
+            (topic, count / total_matches)
+            for topic, count in topic_matches.items()
+        ]
+        
+        # Sort by score
+        return sorted(topic_scores, key=lambda x: x[1], reverse=True)

webstoken/keywords.py

@@ -0,0 +1,216 @@
+"""
+Keyword extraction module using statistical and graph-based approaches.
+"""
+
+from typing import Dict, List, Set, Tuple
+from collections import Counter, defaultdict
+import math
+import re
+
+from .tokenizer import WordTokenizer
+from .normalizer import TextNormalizer
+
+
+class KeywordExtractor:
+    """Keyword extraction using TF-IDF and TextRank-inspired algorithms."""
+    
+    def __init__(self):
+        self.word_tokenizer = WordTokenizer()
+        self.normalizer = TextNormalizer()
+        
+        # Common words to filter out beyond basic stop words
+        self.filter_words: Set[str] = {
+            'would', 'could', 'should', 'said', 'also', 'may', 'might',
+            'must', 'need', 'shall', 'want', 'way', 'time', 'just',
+            'now', 'like', 'make', 'made', 'well', 'back', 'even',
+            'still', 'way', 'take', 'took', 'get', 'got', 'go', 'went'
+        }
+    
+    def _split_into_sentences(self, text: str) -> List[str]:
+        """Split text into sentences using simple rules."""
+        text = re.sub(r'\s+', ' ', text)
+        sentences = re.split(r'[.!?]+', text)
+        return [s.strip() for s in sentences if s.strip()]
+    
+    def _calculate_word_scores(self, text: str) -> Dict[str, float]:
+        """Calculate word importance scores using frequency and position."""
+        # Normalize and tokenize text
+        text = self.normalizer.normalize(text)
+        sentences = self._split_into_sentences(text)
+        
+        word_scores: Dict[str, float] = defaultdict(float)
+        word_positions: Dict[str, List[int]] = defaultdict(list)
+        
+        # Calculate word frequencies and positions
+        for i, sentence in enumerate(sentences):
+            words = self.word_tokenizer.tokenize(sentence)
+            for j, word in enumerate(words):
+                word = word.lower()
+                if (word.isalnum() and 
+                    len(word) > 2 and
+                    word not in self.filter_words and
+                    word not in self.normalizer.stop_words):
+                    word_scores[word] += 1
+                    word_positions[word].append(i)
+        
+        # Adjust scores based on position
+        num_sentences = len(sentences)
+        for word, positions in word_positions.items():
+            # Words appearing in first or last sentences get bonus
+            if 0 in positions:
+                word_scores[word] *= 1.2
+            if num_sentences - 1 in positions:
+                word_scores[word] *= 1.1
+            
+            # Words appearing throughout text get bonus
+            coverage = len(set(positions)) / num_sentences
+            word_scores[word] *= (1 + coverage)
+        
+        return word_scores
+    
+    def _calculate_word_cooccurrence(self, text: str, window_size: int = 3) -> Dict[str, Dict[str, int]]:
+        """Calculate word co-occurrence matrix."""
+        # Normalize and tokenize text
+        text = self.normalizer.normalize(text)
+        words = self.word_tokenizer.tokenize(text)
+        
+        # Filter words
+        filtered_words = [
+            word.lower() for word in words
+            if (word.isalnum() and
+                len(word) > 2 and
+                word.lower() not in self.filter_words and
+                word.lower() not in self.normalizer.stop_words)
+        ]
+        
+        # Build co-occurrence matrix
+        cooccurrence: Dict[str, Dict[str, int]] = defaultdict(lambda: defaultdict(int))
+        
+        for i, word in enumerate(filtered_words):
+            for j in range(max(0, i - window_size), min(len(filtered_words), i + window_size + 1)):
+                if i != j:
+                    cooccurrence[word][filtered_words[j]] += 1
+                    cooccurrence[filtered_words[j]][word] += 1
+        
+        return cooccurrence
+    
+    def _textrank_scores(self, cooccurrence: Dict[str, Dict[str, int]], damping: float = 0.85,
+                        iterations: int = 30) -> Dict[str, float]:
+        """Calculate TextRank scores from co-occurrence matrix."""
+        scores = {word: 1.0 for word in cooccurrence}
+        
+        for _ in range(iterations):
+            new_scores = {}
+            for word in scores:
+                if not cooccurrence[word]:
+                    continue
+                    
+                incoming_score = sum(
+                    scores[other] * cooccurrence[word][other] / sum(cooccurrence[other].values())
+                    for other in cooccurrence[word]
+                )
+                new_scores[word] = (1 - damping) + damping * incoming_score
+            
+            # Check convergence
+            score_diff = sum(abs(new_scores[w] - scores[w]) for w in scores)
+            scores = new_scores
+            if score_diff < 0.0001:
+                break
+        
+        return scores
+    
+    def extract_keywords(self, text: str, num_keywords: int = 10,
+                        use_textrank: bool = True) -> List[Tuple[str, float]]:
+        """
+        Extract keywords from text using combined frequency and graph-based approach.
+        
+        Args:
+            text: Input text
+            num_keywords: Number of keywords to return
+            use_textrank: Whether to use TextRank algorithm
+            
+        Returns:
+            List of (keyword, score) tuples, sorted by score
+        """
+        if not text:
+            return []
+        
+        # Get frequency-based scores
+        freq_scores = self._calculate_word_scores(text)
+        
+        if use_textrank:
+            # Get TextRank scores
+            cooccurrence = self._calculate_word_cooccurrence(text)
+            textrank_scores = self._textrank_scores(cooccurrence)
+            
+            # Combine scores
+            combined_scores = {
+                word: freq_scores[word] * textrank_scores.get(word, 0)
+                for word in freq_scores
+            }
+        else:
+            combined_scores = freq_scores
+        
+        # Sort and return top keywords
+        sorted_words = sorted(
+            combined_scores.items(),
+            key=lambda x: x[1],
+            reverse=True
+        )
+        
+        return sorted_words[:num_keywords]
+    
+    def extract_keyphrases(self, text: str, num_phrases: int = 5,
+                          min_words: int = 2, max_words: int = 4) -> List[Tuple[str, float]]:
+        """
+        Extract key phrases from text.
+        
+        Args:
+            text: Input text
+            num_phrases: Number of phrases to return
+            min_words: Minimum words in phrase
+            max_words: Maximum words in phrase
+            
+        Returns:
+            List of (phrase, score) tuples, sorted by score
+        """
+        # Normalize and split into sentences
+        text = self.normalizer.normalize(text)
+        sentences = self._split_into_sentences(text)
+        
+        # Get word importance scores
+        word_scores = self._calculate_word_scores(text)
+        
+        # Extract candidate phrases
+        phrases: Dict[str, float] = {}
+        
+        for sentence in sentences:
+            words = self.word_tokenizer.tokenize(sentence)
+            
+            # Generate phrases of different lengths
+            for i in range(len(words)):
+                for length in range(min_words, min(max_words + 1, len(words) - i + 1)):
+                    phrase_words = words[i:i+length]
+                    
+                    # Filter phrases
+                    if all(
+                        word.isalnum() and
+                        len(word) > 2 and
+                        word.lower() not in self.filter_words and
+                        word.lower() not in self.normalizer.stop_words
+                        for word in phrase_words
+                    ):
+                        phrase = ' '.join(phrase_words)
+                        # Score is average of word scores
+                        score = sum(word_scores.get(word.lower(), 0) for word in phrase_words)
+                        score /= len(phrase_words)
+                        phrases[phrase] = score
+        
+        # Sort and return top phrases
+        sorted_phrases = sorted(
+            phrases.items(),
+            key=lambda x: x[1],
+            reverse=True
+        )
+        
+        return sorted_phrases[:num_phrases]