hyperpocket 0.0.3__py3-none-any.whl → 0.1.9__py3-none-any.whl

hyperpocket-0.1.9.dist-info/RECORD

@@ -0,0 +1,137 @@
+hyperpocket/__init__.py,sha256=iaJvrZ0rgHwAndGFVv8m1Iz_DWtWEcphFPL-1D8f9SY,136
+hyperpocket/builtin.py,sha256=FnsASGfieQKvVrFVESjvm73qsxPvCf7iiHGd7HNVpuQ,2371
+hyperpocket/constants.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperpocket/pocket_auth.py,sha256=-d5UvLkjvsSkem5DGrDphowckVCB3NCLt2jOw9k5U9c,16934
+hyperpocket/pocket_core.py,sha256=bEl91BFXL1b-JHGPQoK5pzoy-RgDDcyfv0FUQZn86Ss,10175
+hyperpocket/pocket_main.py,sha256=eSwevmX7vgRQebpNtOGG5jhVGU-DE_hTUJi-zRWAvdo,10231
+hyperpocket/prompts.py,sha256=XAmTTCzCkXWK50zcmWmGA25v9-HKd_4dL5o85uisbGM,472
+hyperpocket/tool_like.py,sha256=ur8oMU5p4DUYBEF5MBP3faQ7CKsOzb0lLOaL6p8JqSw,134
+hyperpocket/auth/README.md,sha256=zn4QqnFZCA_4X3x8Wb6lE3OP5otYxpByZaCiUkBvaNs,11562
+hyperpocket/auth/__init__.py,sha256=YcwSdDbOasFDzz0mYJR3aQi3nYfbqtrCSppDWZHOBGY,588
+hyperpocket/auth/context.py,sha256=r19VtTK5FGcmvCgCOr16oNJ0GMFYmgaMEe2EHKJhtQY,1302
+hyperpocket/auth/handler.py,sha256=9R6uQ7bPwmkZUUyg0Q1iOSwmWEQKnGEe92XiLeaxM0w,6580
+hyperpocket/auth/provider.py,sha256=zBuVvrp6SwGRGcfWy6mqIXabw-bfahGfsxpBi899RHs,503
+hyperpocket/auth/schema.py,sha256=8J6PIXpFIJyuVhkZzz6X_TiKOz7sFGdUW0qmZD8x3MA,529
+hyperpocket/auth/calendly/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperpocket/auth/calendly/context.py,sha256=oUQzLy_w5NPvbXjFPOhLD-ggONVSy9VVpFabvX4ZpsY,408
+hyperpocket/auth/calendly/oauth2_context.py,sha256=SiMeZaoWh3aneZVH_MXsT_cZ8qCSVeL-pWHVbfYUS6g,848
+hyperpocket/auth/calendly/oauth2_handler.py,sha256=ulfhIcj_GCGIIZHVV9v42p2miHVsE3fpKODnrwz4qU0,5296
+hyperpocket/auth/calendly/oauth2_schema.py,sha256=9JFogAWFAB7nzCww7NXDYuunY6S28wQZzPX41TWfMig,373
+hyperpocket/auth/github/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperpocket/auth/github/context.py,sha256=Y0QOCNbtQfNDsmgq47s0YGUxTl1QQC-qq4Hm2aZonJ8,404
+hyperpocket/auth/github/oauth2_context.py,sha256=Ge8rkScRpcAWMMzSWTt2gWrDyi0UehTeZepf39Q6BK0,828
+hyperpocket/auth/github/oauth2_handler.py,sha256=4HP0WE9cd3I6v4s9ZXvwNPhFPNk9b6L_MByTOvFvAIc,5059
+hyperpocket/auth/github/oauth2_schema.py,sha256=XfeSF820natq9kwoDKbY2I9TgdjxP-hPkdoGGrKjSuA,371
+hyperpocket/auth/github/token_context.py,sha256=evstL4mZsWHe9Io1RwBc90VfFOnVAbRk8BI1HseYwg8,446
+hyperpocket/auth/github/token_handler.py,sha256=Vz5CqkGk8a6mb4xpw_Lhidwy4cZD7wTrK6iPKIRb15E,2777
+hyperpocket/auth/github/token_schema.py,sha256=8vbJIYWqX_p4GPAtM5xMx5iwo9oZOtZTuSYcnpFGeio,209
+hyperpocket/auth/google/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperpocket/auth/google/context.py,sha256=1ziH27dXPsxp4WkdlyKos37lF623IIs4kX8cmat8QrY,426
+hyperpocket/auth/google/oauth2_context.py,sha256=u7TayAfxPUFWuggtlceub22vHIURF0ZV5Do4jUqLWQ0,1023
+hyperpocket/auth/google/oauth2_handler.py,sha256=547NPhFhi7lpmeVgZ99g_O3IizBMKZ9iAd27RrRNhS4,4880
+hyperpocket/auth/google/oauth2_schema.py,sha256=E_hyNrb-Ro2UWs2AjhmFDBHwaTEsHZa0rQBhUcCWWKk,411
+hyperpocket/auth/gumloop/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperpocket/auth/gumloop/context.py,sha256=6y-5cpQCSEig6qnCWHu1Rvp35DJAibFxKREey8IYFFw,402
+hyperpocket/auth/gumloop/token_context.py,sha256=P92g9O8sKjrJs6RyPAnAwYQxPB6yG0EuljSyIhLvT04,468
+hyperpocket/auth/gumloop/token_handler.py,sha256=nqsHlLU_F4EfA1P629INH2RrUGyof2mOAfp9QnLmM14,2633
+hyperpocket/auth/gumloop/token_schema.py,sha256=hTWWxvL70L35CWtXbBzMF4OMpUDFQIKbDKkjJEQWN7g,209
+hyperpocket/auth/linear/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperpocket/auth/linear/context.py,sha256=hkxVDYO2jB3FCqIz_bMyB3n6OO74PpLI4LiW-42NFNQ,429
+hyperpocket/auth/linear/token_context.py,sha256=KJQXBRSRC1GuIfaIWVahfb-DDraiodAUAL1nxM0vKCQ,471
+hyperpocket/auth/linear/token_handler.py,sha256=wLOodmgXHH4AQWz1tJEHtjrglP3tP1uEDeMQOgQHrRA,2683
+hyperpocket/auth/linear/token_schema.py,sha256=oTy-gOZvXEmGVStgFfnNmlbkknNepOTI5KIeTQLRxus,209
+hyperpocket/auth/notion/README.md,sha256=-pDvDU0CPoM_ZN6HobREV4yHDP0dF2T9_vVJ1cQQz3s,565
+hyperpocket/auth/notion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperpocket/auth/notion/context.py,sha256=Qa-4fCXK661__lXHf5TGu-4mOFlqYCxuDa4IVIDkncA,426
+hyperpocket/auth/notion/token_context.py,sha256=9U5EjgEumYVPT8wEbWrmK0Zz7MzglDl3vGFaVevTqwQ,470
+hyperpocket/auth/notion/token_handler.py,sha256=eK0lJxsGhngXAAaKz_v7aK9YKyiFuMQsLndLPjaOPNs,2586
+hyperpocket/auth/notion/token_schema.py,sha256=z0Ddy438aB8bsEY69B99Bg2KDNnBw2a-DVrbQgehiwg,210
+hyperpocket/auth/reddit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperpocket/auth/reddit/context.py,sha256=WlOvIb4u1PvfrbkYbEq5cSRnXxmIEFuHa4LlKjLEtMc,431
+hyperpocket/auth/reddit/oauth2_context.py,sha256=v1u_uy6O52REp2anteTPNgvb_nX-hI6bM7jNngBZXq4,1015
+hyperpocket/auth/reddit/oauth2_handler.py,sha256=0PLn_A9kkKAXeiEoS11sOaD2p-vyeYFho6_kQhumZJg,5220
+hyperpocket/auth/reddit/oauth2_schema.py,sha256=O93px57D9WMyiY0He-1tAImkCNtorsriRldhlobU6xk,468
+hyperpocket/auth/slack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperpocket/auth/slack/context.py,sha256=f8dMs7QtSSyissOlPGw8rCZXsVUckFnZWjZ_LAmNXpA,429
+hyperpocket/auth/slack/oauth2_context.py,sha256=0FJjJIIcVp1-G4EZu85gJeSXor-zOFI4ua2z0R_sFqI,1374
+hyperpocket/auth/slack/oauth2_handler.py,sha256=8v9gSGkKMPoqEFGFyjCI1qdvklpyeml-5qeoUFo54Xg,5902
+hyperpocket/auth/slack/oauth2_schema.py,sha256=eu2jF2thmaz66AKcnivTvIBLTbeF-a-xQFMkR4RQYX8,1056
+hyperpocket/auth/slack/token_context.py,sha256=isoyUzWlUQ_PliXZ9kKsrbWdOw5oGzrq7MNpnqJ-r5I,461
+hyperpocket/auth/slack/token_handler.py,sha256=yaJtlOqJP436ubY2VluGxLuFpPo0jh8Y8V3PHUai4X8,2557
+hyperpocket/auth/slack/token_schema.py,sha256=mAwOtRO2tW5OtDzbllDJtR_uhLD8ShQAjezkAZnAgd0,207
+hyperpocket/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperpocket/cli/__main__.py,sha256=4f-ks-2Pzo5QfXEx-JwSpz1C43qTJSBBvnERUwsn6rE,416
+hyperpocket/cli/auth.py,sha256=ypxEpa1L3pqrBdABmRdss23uwE-CnMMNDGHGg4UhBYY,4218
+hyperpocket/cli/eject.py,sha256=Te1YhDONk_VCgZ6l2HjLqONJrn04EfPk19sD6D5SOyY,636
+hyperpocket/cli/pull.py,sha256=1Ku0WKLtlZFnEDvU0m10XsVJcysMxDwdEMzTYgNz0xE,548
+hyperpocket/cli/sync.py,sha256=OO5zFrLOMXk7TSAFEew04ZzW4HLoQ1uVb80UKvIJha0,517
+hyperpocket/cli/codegen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperpocket/cli/codegen/auth/__init__.py,sha256=1R2FwRuReAWyeRe1t3-CpR0Mhvb3xWzF8fEkL2mwuB0,545
+hyperpocket/cli/codegen/auth/auth_context_template.py,sha256=FK8ahapEkx-EyGt5WuS4j3kHnS6-8EcXVhZa9KEmjns,569
+hyperpocket/cli/codegen/auth/auth_token_context_template.py,sha256=sOVeGlt7VKNDuQoB3FPC3S2CaU1qZuHuc6F6aXxb0w4,763
+hyperpocket/cli/codegen/auth/auth_token_handler_template.py,sha256=AMb_uZVBKoQlTPofzO_J1FllLqS99eAPA7t_c7RGpTE,3148
+hyperpocket/cli/codegen/auth/auth_token_schema_template.py,sha256=qXpPcTjnhUizVmBlc6VE6IXwe9NSC9fvYxWPipheuXo,427
+hyperpocket/cli/codegen/auth/server_auth_template.py,sha256=28h8s6-C1AqWhghWHDJieuNufdq1UpPvQQ8OIu_NBGw,620
+hyperpocket/config/__init__.py,sha256=deIffu5NBOlSS1X774QuMlf_yb6P2qBQm6tkcf4s8DU,307
+hyperpocket/config/auth.py,sha256=5Zk7OZmElIqIn7LxsT7H4g3bimBxaKpnbL2v9Fs9MlA,797
+hyperpocket/config/git.py,sha256=CGbY7J1LyN4ccZr9CFGAQwwhjC9kvdU0On_nsAsZ1FQ,362
+hyperpocket/config/logger.py,sha256=Wwl-8lllaCNLZruxXU-bcC74Ciy5SmPOX4AJE5BUzWM,2769
+hyperpocket/config/session.py,sha256=CSXENtWx6Gh4DiPh4u9E-4MFYkM8JRjl2hSPV9PVfrE,801
+hyperpocket/config/settings.py,sha256=yXwZN7eryNWxQCK5aRDHQRTzDLATzmSEZwo-6HCxELU,2017
+hyperpocket/futures/__init__.py,sha256=_pRnYZLbogkYFInA3jokkxrcEVRt6YNaBmkf_dSk3SM,136
+hyperpocket/futures/futurestore.py,sha256=WIJGX-XUdB4gWFu2Trto8vd3nTiLFOrnVzQhQP9bO_U,1316
+hyperpocket/repository/__init__.py,sha256=P4Ge__W5wqNgNILNzHjx7qgS8KRcbwri-nb4IPVVErs,219
+hyperpocket/repository/lock.py,sha256=JhuRB1J1rpqGtN19Qeht-iM0BhFuxgl0EaGW9GzqDJA,8046
+hyperpocket/repository/lockfile.py,sha256=1cNkAv5WHU9o8b6arJn9wcosSp3gHMFe11mbAv72Cgs,2187
+hyperpocket/repository/repository.py,sha256=a0HA6eVA88Xq6MYe3SdqBji0U8_RuiaN2v2OYkT8nZY,1349
+hyperpocket/server/__init__.py,sha256=TLqok_mBeV3VRnbZ_spwrwwbsjJ1q9o375AdBk7tKNA,89
+hyperpocket/server/proxy.py,sha256=OhpAWpilM5ioKAsqInKudtvpYk56nMFeZ-dwoGAYIDA,1905
+hyperpocket/server/server.py,sha256=KPHl9WqRAQsQB-6c1D6nFvdJxxFW0dS__ZpF56oNcNU,7838
+hyperpocket/server/auth/__init__.py,sha256=IMjz9PCzD7qh4QIf2g-gWIdkDeU36jt-9F55vaHvLoM,286
+hyperpocket/server/auth/calendly.py,sha256=mi9_ysn0SffhnEgaoNa2jcHWCcD_yzqkS0rvzpJG2Qg,478
+hyperpocket/server/auth/github.py,sha256=cgUtdCYPhf_e51fEQgiYjyG6yuPfMV5RmltjujuWcBw,759
+hyperpocket/server/auth/google.py,sha256=_C33Bzow7yzjnvf0WUObu8p-dSU5rXqBgSPrENORAmY,470
+hyperpocket/server/auth/gumloop.py,sha256=t_BUQ7RR8_x-ogqXnQ3iNHTVthzJyUTN03iqtRpWUTU,475
+hyperpocket/server/auth/linear.py,sha256=3Ii8jewBCwS2pH3_mSJzBWot1t8IcVghC9K_ohid-H8,448
+hyperpocket/server/auth/notion.py,sha256=CNOLVh2gA2xrVxXgqIAc18dpSTPwM98M-5rFGObBr3k,458
+hyperpocket/server/auth/reddit.py,sha256=UloBQNEdhU1_eXaF8qVSQ5ivq5xtWINsHvBDGwgFSLM,443
+hyperpocket/server/auth/slack.py,sha256=HSfru4_S3B_sEF_keCBLEsNyYeyc92eL5I2a-2TKf64,716
+hyperpocket/server/auth/token.py,sha256=Q38Tt5ly2vLsR0dxjmnJNX2IqS-FkTsm94bO6e2wtYk,1700
+hyperpocket/server/tool/__init__.py,sha256=khNLe3H2W7WXKQlHjXuuvd9R87eHOAZhDsQmjDcbYsg,210
+hyperpocket/server/tool/wasm.py,sha256=N14Sg70cIqTCegmXkrf3HPEwZ_jjKkeiw9G6xJJc-NE,1705
+hyperpocket/server/tool/dto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperpocket/server/tool/dto/script.py,sha256=yRBFBz1T4TpssyEqMTEf_E1IdklY0twn1o-FDcXcjDw,847
+hyperpocket/session/README.md,sha256=Wmh-qWJQ-40vU9hP5jNxuM33i0STNfaIjOecba7H-oc,1968
+hyperpocket/session/__init__.py,sha256=-zdfZfXwR336liAYjwcZULIHg_72NxMMcDFz_RQGLGk,260
+hyperpocket/session/in_memory.py,sha256=pD4ZEqsFqLmVOvsDbEcJkUN9nvlJgCXTGapH_PLljYk,3449
+hyperpocket/session/interface.py,sha256=0o5IwXezaR5NKB6F9vfumLnrBSYv7JzY_FAvZB6uuvw,4879
+hyperpocket/session/redis.py,sha256=6SHR2ZJ5E3RS-G_xzeh5ls_cPZ0NarPetlEuaAtqEAk,5467
+hyperpocket/tool/README.md,sha256=vbHvP3fnfihq-H481MiSZEVJNhVoUu0djENb9tiy78c,3026
+hyperpocket/tool/__init__.py,sha256=PlSewsugQ6x4BXszWvmTiW-MfVS87TALvWi4TcIgreY,346
+hyperpocket/tool/tool.py,sha256=9kALM1hk_IE1f9y9DK-_e0Ya5gNuP7oni1pfHU-e2_8,7282
+hyperpocket/tool/function/README.md,sha256=6Y9a8FlFjEdbrVqF0NoQ1j34VoV8Zt6Pf9-xlLIHkTc,3676
+hyperpocket/tool/function/__init__.py,sha256=elshxOWjKUCKSsSSkae8GB65bZ4xG1Xa4o2GCT5QbF4,259
+hyperpocket/tool/function/annotation.py,sha256=UaeawAkX3QNAWLYHCQ-V5UNZyfxpOOvbYs3w5Q8bJq4,1018
+hyperpocket/tool/function/tool.py,sha256=EENaORdCLVz2HM7fdJhDsLCJfixDC4j2Hdf0GnJ-OOg,6034
+hyperpocket/tool/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hyperpocket/tool/wasm/README.md,sha256=QeR7mI8RD6OJ2AXdZCpzNLBW0KUVgYQ0IqCc-wVXgFs,3896
+hyperpocket/tool/wasm/__init__.py,sha256=KGOPPyA1CnbW-T9bgSpfIXf9952l_p5HJDhHGBb3b9o,71
+hyperpocket/tool/wasm/browser.py,sha256=a4TbetonEvClgkfQgTxpIN6a9IxZVB1jjSD3dBF8gNg,1851
+hyperpocket/tool/wasm/invoker.py,sha256=u8ZfGW871IVBaG4_XbOQHfp7QYLS093QdwVa3HOL-_k,1520
+hyperpocket/tool/wasm/script.py,sha256=b0il5tTF8bcMDcfR_ME8V2TppdnPDjNK2rB1GxeH5Pk,4251
+hyperpocket/tool/wasm/tool.py,sha256=GPTxgXEV9DbBbW848TqzNHvVbwk2oMmI__kUhHsuLNw,5199
+hyperpocket/tool/wasm/templates/__init__.py,sha256=cQ-uNsO418xvv54i8bD0IrqcAKUxMuyZoG3ShP72olw,949
+hyperpocket/tool/wasm/templates/node.py,sha256=8ghVQGS9L3IJGdBB8waLK_ej4FS34dCA_bwPKjm8QSU,2782
+hyperpocket/tool/wasm/templates/python.py,sha256=Gi_tn3QQZjolFpbhVDXHLoj4juRLTEGsq_A-iyvTyUk,2733
+hyperpocket/util/__init__.py,sha256=V36_ztskLaKQxOhW2OhrhxRFn4QCxtX3jGjAT4lqNQE,35
+hyperpocket/util/extract_func_param_desc_from_docstring.py,sha256=3bek0BRwDGdlKBATDAhBrSSqzdVshXKD02zNi6KvxO4,4067
+hyperpocket/util/find_all_leaf_class_in_package.py,sha256=afGLqe5s7irOOPh7DI70v-utDL2a0vhNzHjtgSmDeZU,528
+hyperpocket/util/find_all_subclass_in_package.py,sha256=CfsM5sWHHbFZD6M-jbJRN8Zo3m57R1E7FGg_V__HdFU,964
+hyperpocket/util/flatten_json_schema.py,sha256=PXK6I1S2QDxwSGmUVEl5bbSPrjTa38GBllBQ8uKXJNQ,1587
+hyperpocket/util/function_to_model.py,sha256=zPBrxtvfieJearmvJeMOeIGGLn1ymXNvL9PlMoXZbwA,2061
+hyperpocket/util/get_objects_from_subpackage.py,sha256=Aq87PD_H57c2IjLS28Hf0Wu5vLVyoOtDoBvKzvQ1UPw,929
+hyperpocket/util/json_schema_to_model.py,sha256=hmXqiU67WrdHZMGELvHfKxfQ12EqPtTD8x_KezCcEFk,3465
+hyperpocket-0.1.9.dist-info/METADATA,sha256=xXCNAMvXwN0u0ZhkITy943hcfjKj1VE-Rm6my2kFBHM,9961
+hyperpocket-0.1.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperpocket-0.1.9.dist-info/entry_points.txt,sha256=KpBleaYr0SaENXOa-dFvJ_cvFCHYFEQ4LMl11ShAcBI,61
+hyperpocket-0.1.9.dist-info/RECORD,,

{hyperpocket-0.0.3.dist-info → hyperpocket-0.1.9.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

hyperpocket-0.1.9.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+hyperpocket = hyperpocket.cli.__main__:cli

hyperpocket/auth/README.KR.md

@@ -1,309 +0,0 @@
-## Auth
-
-각 provider에서 유저를 식별하기 위한 프로세스
-
-### AuthContext
-
-실제 유저의 인증 정보(e.g., access token)을 담고 있는 객체
-
-```python
-class AuthContext(BaseModel, ABC):
-    """
-    This class is used to define the interface of the authentication model.
-    """
-    access_token: str = Field(description="user's access token")
-    description: str = Field(description="description of this authentication context")
-    expires_at: Optional[datetime] = Field(description="expiration datetime")
-    detail: Optional[Any] = Field(default=None, description="detailed information")
-```
-
-일반적으로 해당 객체에서 access token의 key 정보나 response 객체를 AuthContext로 변환해주는 역할을 수행한다.
-
-### AuthenticateRequest
-
-authentication 수행 시에 필요한 정보를 담고 있는 객체
-
-```python
-class AuthenticateRequest(BaseModel):
-    auth_scopes: Optional[list[str]] = Field(default_factory=list,
-                                             description="authentication scopes. if the authentication handler is non scoped, it isn't needed")
-```
-
-- 일반적으로 인증 시에 필요한 client id 및 secret id 등과 같은 정보를 request에 같이 전달한다.
-
-**examples**
-
-```python
-class GitHubOAuth2Request(AuthenticateRequest):
-    client_id: str
-    client_secret: str
-```
-
-### AuthenticateResponse(Optional)
-
-authentication response에서 필수 정보를 담고 있는 객체
-
-```python
-class AuthenticateResponse(BaseModel):
-    """
-    This class is used to define the interface of the authentication response.
-    """
-    pass
-```
-
-- handler에서 response를 dict 형태로 처리한다면, 구현할 필요가 없다.
-
-### AuthHandlerInterface
-
-실제 authentication을 수행하는 객체
-
-```python
-class AuthHandlerInterface(ABC):
-    name: str = Field(description="name of the authentication handler")
-    description: str = Field(description="description of the authentication handler")
-    scoped: bool = Field(description="Indicates whether the handler requires an auth_scope for access control")
-    
-
-    @staticmethod
-    def provider() -> AuthProvider:
-        """
-        Returns the authentication provider enum.
-
-        This method is used to determine the appropriate authentication handler
-        based on the authentication provider.
-        """
-        raise NotImplementedError()
-
-    @staticmethod
-    def provider_default() -> bool:
-        """
-        Indicates whether this authentication handler is the default handler.
-
-        If no specific handler is designated, the default handler will be used.
-
-        Returns:
-            bool: True if this handler is the default, False otherwise.
-        """
-        return False
-
-    @staticmethod
-    def recommended_scopes() -> set[str]:
-        """
-        Returns the recommended authentication scopes.
-
-        If `use_recommended_scope` is set to True in the `AuthConfig`,
-        this method should return the proper recommended scopes. Otherwise,
-        it should return an empty set.
-
-        Returns:
-            set[str]: A set of recommended scopes, or an empty set if not applicable.
-
-        Examples:
-            Slack OAuth2 recommended_scopes::
-
-                def recommended_scopes() -> set[str]:
-                    if config.auth.slack.use_recommended_scope:
-                        recommended_scopes = {
-                            "channels:history",
-                            "channels:read",
-                            "chat:write",
-                            "groups:history",
-                            "groups:read",
-                            "im:history",
-                            "mpim:history",
-                            "reactions:read",
-                            "reactions:write",
-                        }
-                    else:
-                        recommended_scopes = {}
-                    return recommended_scopes
-        """
-        raise NotImplementedError()
-
-    def make_request(self, auth_scopes: Optional[list[str]] = None, **kwargs) -> AuthenticateRequest:
-        """
-        Make an AuthenticationRequest.
-
-        Usually, this method only requires `auth_scopes`.
-        If additional static information is needed (e.g., clientID, secretID),
-        retrieve it from the configuration.
-
-        Args:
-            auth_scopes (Optional[list[str]]): list of auth scopes
-
-        Returns:
-            AuthenticateRequest: A authentication request object with the necessary details.
-
-        Examples:
-            Create a Slack OAuth2 request::
-
-                def make_request(self, auth_scopes: Optional[list[str]] = None, **kwargs) -> SlackOAuth2Request:
-                    return SlackOAuth2Request(
-                        auth_scopes=auth_scopes,
-                        client_id=config.auth.slack.client_id,
-                        client_secret=config.auth.slack.client_secret
-                    )
-        """
-        raise NotImplementedError()
-
-    def prepare(self, auth_req: AuthenticateRequest, thread_id: str, profile: str,
-                future_uid: str, *args, **kwargs) -> str:
-        """
-        Performs preliminary tasks required for authentication.
-
-        This method typically performs the following actions:
-        - Creates a future to wait for user authentication completion during the authentication process.
-        - Issues an authentication URI that the user can access.
-
-        Args:
-            auth_req (AuthenticateRequest): The authentication request object.
-            thread_id (str): The thread ID.
-            profile (str): The profile name.
-            future_uid (str): A unique identifier for each future.
-
-        Returns:
-            str: The authentication URI that the user can access.
-        """
-        raise NotImplementedError()
-
-    @abstractmethod
-    async def authenticate(self, auth_req: AuthenticateRequest, future_uid: str, *args, **kwargs) -> AuthContext:
-        """
-        Performs the actual authentication process.
-
-        This function assumes that the user has completed the authentication during the `prepare` step,
-        and the associated future has been resolved. At this point, the result contains the required
-        values for authentication (e.g., an auth code).
-
-        Typically, this process involves:
-        - Accessing the resolved future to retrieve the necessary values for authentication.
-        - Performing the actual authentication using these values.
-        - Converting the returned response into an appropriate `AuthContext` object and returning it.
-
-        Args:
-            auth_req (AuthenticateRequest): The authentication request object.
-            future_uid (str): A unique identifier for the future, used to retrieve the correct
-                              result issued during the `prepare` step.
-
-        Returns:
-            AuthContext: The authentication context object containing the authentication result.
-        """
-        raise NotImplementedError()
-
-    @abstractmethod
-    async def refresh(self, auth_req: AuthenticateRequest, context: AuthContext, *args, **kwargs) -> AuthContext:
-        """
-        Performs re-authentication for an expired session.
-
-        This method is optional and does not need to be implemented for handlers that do not require re-authentication.
-
-        Typically, the information needed for re-authentication (e.g., a refresh token) should be stored
-        within the `AuthContext` during the previous authentication step.
-        In the `refresh` step, this method accesses the necessary re-authentication details from the provided `context`,
-        performs the re-authentication, and returns an updated `AuthContext`.
-
-        Args:
-            auth_req (AuthenticateRequest): The authentication request object.
-            context (AuthContext): The current authentication context that it should contain data required for re-authentication.
-
-        Returns:
-            AuthContext: An updated authentication context object.
-        """
-        raise NotImplementedError()
-```
-
-## How To Implement Auth
-
-1. `AuthenticateRequest`을 상속받은 구현체 구현
-    - 해당 클래스에서는 실제 prepare 및 authenticate를 할 때 필요한 정보를 저장하고 있어야 합니다.
-
-2. `AuthContext`을 상속받은 구현체 구현
-    - Context 내에는 다음과 같은 정보들이 존재해야 합니다.
-    - 각 tool에서 접근할 수 있는 access_key
-    - response를 context로 변환할 수 있는 함수
-
-3. `Response`(Optional) 객체 구현
-    - 필요시 authentication을 완료 후 받은 정보를 parsing할 구현체를 구현
-
-4. `AuthHandlerInterface`을 상속받은 구현체 구현
-    - 실제 prepare, authentication, refresh를 수행할 객체를 구현합니다.
-
-5. (신규 auth provider인 경우) `AuthProvider`에 새로운 enum value를 추가
-    - 만약 새로운 `AuthProvider`가 추가되는 경우라면, `pocket/auth/provider.py` 내에 새로운 AuthProvider Enum을 등록해야 합니다.
-
-6. 신규 Auth callback server enpoint 추가
-    - `pocket/server/auth/` 하위에 유저가 authentication을 완료하면 callback될 server endpoint를 추가해야 합니다.
-    - 해당 패키지 하위에 적절한 `APIRouter`를 선언해놓으면 pocket 초기화 시에 자동으로 end point를 pocket server에 등록해주게 됩니다.
-
-7. Auth Test code 추가(Optional)
-    - `pocket/auth/tests` 하위에 테스트 코드 추가
-
----
-
-## Auth Flow(Advanced)
-
-### Session State 정의
-
-- SKIP_AUTH : Auth가 존재하고, 들어온 요청에 대한 권한도 가지고 있는 상태
-- DO_AUTH : Auth가 존재하지만, 들어온 요청에 대한 권한이 없기 때문에 auth가 필요한 상태
-- DO_REFRESH : Auth가 존재하지만, 만료가 되어 refresh가 필요한 상태
-- NO_SESSION : Auth가 존재하지 않는 상태
-- PENDING_RESOLVE : Resource Owner에게 authorization URI를 전달하고 인증을 기다리는 상태
-- RESOLVED : Resource Owner가 authorization을 완료해 서버에서 code를 받은 상태
-
-### 01. check
-
-처음 요청이 들어왔을 때 현재 사용자의 session이 어느 상태인지를 check하게 된다.
-
-1. 사용자의 현재 session 조회
-    - 존재 하지 않으면 NO_SESSION 상태 반환
-2. session의 auth resolve uid가 존재하는지 확인
-    - auth resolve uid가 아직 존재하는 것은 사용자에게 authentication URI는 전달하였지만 서버에서 access token을 아직 얻지는 못 한 상태
-    - auth resolve uid가 존재하면서 현재 사용자가 인증을 완료한 상태인지 확인
-        - 사용자가 인증을 완료한 상태라면 RESOLVED 상태 반환
-        - 사용자가 인증을 완료하지 못 한 상태라면 PENDING_RESOLVE 상태 반환
-3. 현재 인증된 session이 현재 요청에 적용이 가능한지를 확인
-    - 현재 session의 auth provider와 필요한 session의 auth provider가 동일한지를 확인
-        - 다르다면 반드시 재인증이 필요
-    - 현재 session을 인증한 auto provider가 non scoped인지 확인
-        - scoped가 아닌 경우에는 모든 권한이 있기 때문에 항상 사용 가능
-    - scoped인 경우 필요한 scope을 이미 가지고 있는지 확인
-        - 이미 가지고 있는 경우 그대로 사용하면 된다.
-        - 가지고 있지 않은 경우 새로운 인증 요청이 필요. 이때 기존 갖고 있던 scope과 새로 필요한 scope의 합집합을 다시 요청하게 된다.
-    - 위 과정을 통해 현재 session에서 적용이 불가능 하다고 판단되면 DO_AUTH 상태 반환
-4. 현재 인증된 session이 만료되었는지 확인
-    - 만료되었다면 DO_REFRESH 상태 반환
-5. 위 단계를 모두 통과한 경우에만 SKIP_AUTH 상태 반환
-
-### 02. prepare
-
-1. auth state가 SKIP_AUTH, DO_REFRESH, RESOLVED인 경우에는 그대로 함수를 종료
-2. DO_AUTH, NO_SESSION인 경우에는 새로운 session과 future를 만들고, 사용자에게 authenticate URI를 반환
-3. PENDING_RESOLVED인 경우에는 기존 session의 authenticate URI를 다시 반환
-
-```mermaid
-flowchart TD
-    Check["Prepare Auth"] --> A["Is AuthState<br>SKIP_AUTH, DO_REFRESH or RESOLVED?"]
-    A -->|Yes| B["Return<br>None"]
-    A -->|No| C["Is AuthState PENDING_RESOLVED?"]
-    C -->|YES| D["Return<br>Previous Authorization URI"]
-    C -->|NO| E["Make New Session"]
-    E --> F["Return<br>Authorization URI"]
-```
-
-### 03. Authenticate
-
-1. auth state가 SKIP_AUTH인 경우에는 기존 session을 그대로 반환
-2. auth state가 DO_REFRESH인 경우에는 refresh를 수행하고 기존 session을 교체
-3. auth state가 PENDING_RESOLVE 또는 RESOLVED인 경우에는 사용자로부터 전달받은 code로 authenticate를 수행
-4. 그 외 auth state(NO_SESSION, DO_AUTH)는 해당 단계로 진입하지 않는다.
-
-```mermaid
-flowchart TD
-    Check["Authenticate"]
-    Check -->|Is AuthState<br>SKIP_AUTH?| A2["Return<br>Existing Session"]
-    Check -->|Is AuthState<br>DO_REFRESH?| B2["Refresh<br>Access Token"]
-    Check -->|Is AuthState PENDING_RESOLVE<br>or<br>RESOLVED?| C2["Wait for Code<br>And<br>Authenticate"]
-    Check -->|Is AuthState<br>NO_SESION<br>or<br>DO_AUTH?| D2["Can't be reached<br>while in state"]
-```
-

hyperpocket/auth/slack/tests/test_oauth2_handler.py

@@ -1,32 +0,0 @@
-# import asyncio
-# from unittest import TestCase
-#
-# from pocket.auth.slack.oauth2_handler import SlackOAuth2AuthHandler
-# from pocket.auth.slack.oauth2_schema import SlackOAuth2Request
-# from pocket.config import config
-# from pocket.server.server import get_proxy_server, get_server
-#
-#
-# class TestSlackOAuth2AuthHandler(TestCase):
-#
-#     def test_authenticate(self):
-#         loop = asyncio.new_event_loop()
-#         asyncio.set_event_loop(loop)
-#         server = get_server()
-#         asyncio.ensure_future(server.serve(), loop=loop)
-#         proxy_server = get_proxy_server()
-#         if proxy_server:
-#             asyncio.ensure_future(proxy_server.serve(), loop=loop)
-#
-#         slack_auth = SlackOAuth2AuthHandler()
-#         auth_req = SlackOAuth2Request(
-#             auth_scopes=["channels:history", "im:history", "mpim:history", "groups:history", "reactions:read"],
-#             client_id=config.auth.slack.client_id,
-#             client_secret=config.auth.slack.client_secret,
-#         )
-#
-#         # when
-#         context = loop.run_until_complete(slack_auth.authenticate(auth_req))
-#
-#         # then
-#         print("access_token : ", context.access_token)

hyperpocket/auth/slack/tests/test_token_handler.py

@@ -1,23 +0,0 @@
-# import asyncio
-# from unittest import TestCase
-# from unittest.mock import patch
-#
-# from pocket.auth.context import AuthContext
-# from pocket.auth.slack.token_handler import SlackTokenAuthHandler
-# from pocket.auth.slack.token_schema import SlackTokenRequest
-#
-#
-# class TestSlackTokenAuthHandler(TestCase):
-#     def test_authenticate(self):
-#         loop = asyncio.new_event_loop()
-#         asyncio.set_event_loop(loop)
-#
-#         slack_auth = SlackTokenAuthHandler()
-#         auth_req = SlackTokenRequest()
-#
-#         # when
-#         with patch("builtins.input", return_value="test-slack-token"):
-#             context: AuthContext = loop.run_until_complete(slack_auth.authenticate(auth_req))
-#
-#         # then
-#         assert context.access_token == "test-slack-token"

hyperpocket/auth/tests/test_google_oauth2_handler.py

@@ -1,147 +0,0 @@
-import uuid
-from datetime import timezone, datetime
-from unittest import IsolatedAsyncioTestCase
-from unittest.mock import patch
-from urllib.parse import urlparse, parse_qs
-
-import httpx
-
-from hyperpocket.auth import GoogleOAuth2AuthContext
-from hyperpocket.auth.google.oauth2_handler import GoogleOAuth2AuthHandler
-from hyperpocket.auth.google.oauth2_schema import GoogleOAuth2Request, GoogleOAuth2Response
-from hyperpocket.config import config
-from hyperpocket.config.auth import GoogleAuthConfig
-from hyperpocket.futures import FutureStore
-
-
-class TestGoogleOAuth2AuthHandler(IsolatedAsyncioTestCase):
-
-    async def asyncSetUp(self):
-        config.auth.google = GoogleAuthConfig(
-            client_id="test-client-id",
-            client_secret="test-client-secret",
-        )
-
-        self.handler = GoogleOAuth2AuthHandler()
-        self.auth_req = GoogleOAuth2Request(
-            auth_scopes=["https://www.googleapis.com/auth/calendar"],
-            client_id="test-client-id",
-            client_secret="test-client-secret",
-        )
-
-    async def test_make_auth_url(self):
-        future_uid = str(uuid.uuid4())
-
-        auth_url = self.handler._make_auth_url(
-            auth_req=self.auth_req,
-            redirect_uri="http://test-redirect-uri.com",
-            state=future_uid
-        )
-        parsed = urlparse(auth_url)
-        query_params = parse_qs(parsed.query)
-        base_url = f"{parsed.scheme}://{parsed.netloc}{parsed.path}"
-
-        # then
-        self.assertEqual(base_url, self.handler._GOOGLE_AUTH_URL)
-        self.assertEqual(query_params["state"][0], future_uid)
-        self.assertEqual(query_params["redirect_uri"][0], "http://test-redirect-uri.com")
-        self.assertEqual(query_params["client_id"][0], "test-client-id")
-        self.assertEqual(query_params["scope"][0], "https://www.googleapis.com/auth/calendar")
-
-    async def test_prepare(self):
-        future_uid = str(uuid.uuid4())
-
-        # when
-        prepare: str = self.handler.prepare(
-            auth_req=self.auth_req,
-            thread_id="test-prepare-thread-id",
-            profile="test-prepare-profile",
-            future_uid=future_uid,
-        )
-        auth_url = prepare.removeprefix("User needs to authenticate using the following URL:").strip()
-        future_data = FutureStore.get_future( uid=future_uid)
-
-        # then
-        self.assertTrue(auth_url.startswith(self.handler._GOOGLE_AUTH_URL))
-        self.assertIsNotNone(future_data)
-        self.assertEqual(future_data.data["thread_id"], "test-prepare-thread-id")
-        self.assertEqual(future_data.data["profile"], "test-prepare-profile")
-        self.assertFalse(future_data.future.done())
-
-    async def test_authenticate(self):
-        mock_response = httpx.Response(
-            status_code=200,
-            json={
-                "access_token": "test-token",
-                "refresh_token": "test-refresh-token",
-                "expires_in": 3600,
-                "scope": "https://www.googleapis.com/auth/calendar",
-                "token_type": "Bearer",
-
-            }
-        )
-        future_uid = str(uuid.uuid4())
-
-        self.handler.prepare(
-            auth_req=self.auth_req,
-            thread_id="test-thread-id",
-            profile="test-profile",
-            future_uid=future_uid
-        )
-        future_data = FutureStore.get_future( uid=future_uid)
-        future_data.future.set_result("test-code")
-
-        with patch("httpx.AsyncClient.post", return_value=mock_response):
-            response: GoogleOAuth2AuthContext = await self.handler.authenticate(
-                auth_req=self.auth_req,
-                future_uid=future_uid
-            )
-
-        time_diff = (response.expires_at - datetime.now(tz=timezone.utc)).total_seconds()
-
-        self.assertIsInstance(response, GoogleOAuth2AuthContext)
-        self.assertEqual(response.access_token, "test-token")
-        self.assertEqual(response.refresh_token, "test-refresh-token")
-        self.assertTrue(time_diff > 3500)
-
-    async def test_refresh(self):
-        # given
-        mock_response = httpx.Response(
-            status_code=200,
-            json={
-                "access_token": "new-test-token",
-                "expires_in": 3600,
-                "scope": "https://www.googleapis.com/auth/calendar",
-                "token_type": "Bearer",
-            }
-        )
-        response = GoogleOAuth2Response(
-            **{
-                "access_token": "test-token",
-                "expires_in": 100,
-                "scope": "https://www.googleapis.com/auth/calendar",
-                "refresh_token": "test-refresh-token",
-                "token_type": "Bearer",
-            }
-        )
-        context = GoogleOAuth2AuthContext.from_google_oauth2_response(response)
-
-        # when
-        with patch("httpx.AsyncClient.post", return_value=mock_response):
-            new_context: GoogleOAuth2AuthContext = await self.handler.refresh(
-                auth_req=self.auth_req,
-                context=context
-            )
-
-        old_time_diff = (context.expires_at - datetime.now(tz=timezone.utc))
-        new_time_diff = (new_context.expires_at - datetime.now(tz=timezone.utc))
-
-        # then
-        self.assertIsInstance(new_context, GoogleOAuth2AuthContext)
-        self.assertEqual(context.access_token, "test-token")
-        self.assertEqual(context.refresh_token, "test-refresh-token")
-        self.assertTrue(old_time_diff.total_seconds() < 100)
-
-        self.assertEqual(new_context.access_token, "new-test-token")
-        self.assertEqual(new_context.refresh_token, "test-refresh-token")
-        self.assertTrue(new_time_diff.total_seconds() > 3500)