clear-skies 2.0.2__py3-none-any.whl → 2.0.4__py3-none-any.whl

{clear_skies-2.0.2.dist-info → clear_skies-2.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: clear-skies
-Version: 2.0.2
+Version: 2.0.4
 Summary: A framework for building backends in the cloud
 License: MIT
 Author: Conor Mancone
@@ -32,15 +32,5 @@ Description-Content-Type: text/markdown
 
 clearskies is a very opinionated Python framework intended for developing microservices in the cloud via declarative programming principles.  It is mainly intended for backend services and so is designed for RESTful API endpoints, queue listeners, scheduled tasks, and the like.
 
-## Installation, Documentation, and Usage
-
-To install:
-
-```bash
-pip3 install clear-skies
-```
-
-Documentation is under construction here:
-
 [https://clearskies.info](https://clearskies.info)
 

{clear_skies-2.0.2.dist-info → clear_skies-2.0.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-clearskies/__init__.py,sha256=x9m4Bu6Fs4YwaT6p1i7R-6juPugmYyKYtoiyOaL_QbU,1083
+clearskies/__init__.py,sha256=pvReM1OEkMlXGPR56eNUq1DDantH9ds9szCXI9O-wOQ,1123
 clearskies/action.py,sha256=x_T05XaC0m-BYPZWaSR94XbE7T5ZK1vRtSfEszfZuDg,121
 clearskies/authentication/__init__.py,sha256=MxXNCWhKbha7TPu_MAyssfTdOCEDSNBwzshEHx8gfHo,525
 clearskies/authentication/authentication.py,sha256=N-g2qNDGuJaSlMwc_SRwsjAuqOMLI2nKfUzSCF7HOFo,1240
@@ -9,8 +9,8 @@ clearskies/authentication/public.py,sha256=GSNl4X4fnB25BZoXSo8nqL0iZCa9rzfvPfIsJ
 clearskies/authentication/secret_bearer.py,sha256=JoGBD2s7MubidFi1L0hyB_A4V3w5n1LKsokLiT44fBc,17590
 clearskies/autodoc/__init__.py,sha256=JRUAmd0he8iGlgiZvxewLMIXJqnOFEdvlaKAtHpC2lo,124
 clearskies/autodoc/formats/__init__.py,sha256=3rhoLKmEwT6PljaHvOl9qdeMIXyD7PQBZbqZKy5Mb5I,56
-clearskies/autodoc/formats/oai3_json/__init__.py,sha256=C9DzR38Uu0t41osMzhQx6K-hyaNWA1t6agTzOXW9k88,142
-clearskies/autodoc/formats/oai3_json/oai3_json.py,sha256=8q3_-Ea-nKySszDQTU2rTyGrp0t_X3IjUMfH1vLt4z8,3052
+clearskies/autodoc/formats/oai3_json/__init__.py,sha256=tbbOZWkX9ZWj4BM3arHrlmqy4ZrScmIv2bazadbQt1w,142
+clearskies/autodoc/formats/oai3_json/oai3_json.py,sha256=-LViw86zpPAgAEnC42KuobccvFATRg-j8ZEd8BiTYFA,2964
 clearskies/autodoc/formats/oai3_json/oai3_schema_resolver.py,sha256=5gifJ36dyWEeYtfjHVbbTpPBo0BB1Gqxt0Y3sxTiHJA,509
 clearskies/autodoc/formats/oai3_json/parameter.py,sha256=h9bHXxqJhUc7NRQCZF6RnIPuaY9BA6V_xzYNnsplXlc,1110
 clearskies/autodoc/formats/oai3_json/request.py,sha256=WHEWQvhuhkw82V4YS6GwDN4y8Qy7QDSn9awJEhwLmWU,2939
@@ -19,14 +19,14 @@ clearskies/autodoc/formats/oai3_json/schema/__init__.py,sha256=VJiDueMdGfJoVQVt9
 clearskies/autodoc/formats/oai3_json/schema/array.py,sha256=1VOrMC_i1JSu1Gw2cqQ7uVDhSk-xNm25io7oBQL9PZM,310
 clearskies/autodoc/formats/oai3_json/schema/default.py,sha256=BhwQebdIaK6rrATu6yZxPU3bqVmd4LFKTTlydJVl644,484
 clearskies/autodoc/formats/oai3_json/schema/enum.py,sha256=7qkpYWXPwbkgkoHPAowMIHJeGNb81qQmTmIIdc5yJbA,265
-clearskies/autodoc/formats/oai3_json/schema/object.py,sha256=-RLIbma-yG6XjGwzBAP7b-smwLhMronW-kdoP5T-Nfk,878
+clearskies/autodoc/formats/oai3_json/schema/object.py,sha256=HkLg3A6cTwV9h3QiXPpoVG7bH8U-aKFzp7nyGClGBgQ,1073
 clearskies/autodoc/formats/oai3_json/test.json,sha256=DdMvSUbaTEAyWtX_RDxEFR82kK9pCCTeFUghQwHjB3s,59848
 clearskies/autodoc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clearskies/autodoc/request/__init__.py,sha256=-L1hZ70QKn0yzXJtpQS741lbcYXA4i0xQnkebKDjzsA,303
 clearskies/autodoc/request/header.py,sha256=TCeRyFFqcgNN8o9vEmc0JTxs7vRlMHnlhs7zsYfShRM,104
 clearskies/autodoc/request/json_body.py,sha256=qURg3_4fQA9ZUVeR_T0g-RZ8seFIrI0ME-s4PzosfGE,108
 clearskies/autodoc/request/parameter.py,sha256=Z7l7gdsOw-SSLYfL8kQmLnslg89JUQObppxatJiI2sA,233
-clearskies/autodoc/request/request.py,sha256=t1LRnf440xtLaDm8xlbWH9RWtliAstczbKbOsU8HfXg,1371
+clearskies/autodoc/request/request.py,sha256=k9876Pu27H3K-AXlmhOGPrc1W2L972_ugEExWiqW4aU,1814
 clearskies/autodoc/request/url_parameter.py,sha256=mwM9Fe16h_8tdPXvXokjzOH1I2Txs-GFjK1a9FQND2w,117
 clearskies/autodoc/request/url_path.py,sha256=WmZDltORzCir4Ei6_XqoBlh7UBpZZmvZIDfaQezGtmc,107
 clearskies/autodoc/response/__init__.py,sha256=a0vlujvsyLkq1zleRTqcGULoaXTJLkjyTKCUWdsq8Uc,62
@@ -48,14 +48,14 @@ clearskies/autodoc/schema/schema.py,sha256=KZ4r88OUMzbeV4DQ3yUhK8bHS_zJiimsWPWc1
 clearskies/autodoc/schema/string.py,sha256=GXRI-aU8PYmjfnhmfaOe4vq7JASb-aB4SiFeG-EmJY0,60
 clearskies/backends/__init__.py,sha256=krBB3gHLP-lVYkm5ksdK7teEtouAHhL3EC__WGVnF4A,3157
 clearskies/backends/api_backend.py,sha256=IOT4JqSxtKGqyBawg0TvE8rQJpHcHdQ8t0LDaLXfxow,54879
-clearskies/backends/backend.py,sha256=_TFMXAHgIY-vPGhx8SYjSTbVd9r-6KpLbLnfNsCXuV8,5874
+clearskies/backends/backend.py,sha256=xjQGzLtj4de7rVp1m_Aa_HdrHwQUdg-P_32Bb0y2tq0,5876
 clearskies/backends/cursor_backend.py,sha256=lMnkHATU2Fxr0ihgrVnvI9IVnUPxNfjzpkdJIok2mXY,14360
 clearskies/backends/memory_backend.py,sha256=fXgbFcTvbZeKHs4CsI_yNsofHSjWqZqY9QWI7uJzVws,34260
 clearskies/backends/secrets_backend.py,sha256=r1k7YfZ7AKMsN2wWwx939QKeYWgh6PVkdiKayzPBDv0,4275
 clearskies/column.py,sha256=_VkvfD_6d4brTkChUbevJe9e7sla8ovsiJ5cH1evoH4,52070
 clearskies/columns/__init__.py,sha256=a__-1hv-aMV3RU0Sd-BEkfItSJaG51EF2VeRQoTdka8,1990
 clearskies/columns/audit.py,sha256=0BBpBFsxz6JBWDPoyCb73EDJnN95pj1TXtTZqbT1qKU,7628
-clearskies/columns/belongs_to_id.py,sha256=VtI_LjaBRMNGoeZlF4WvTCgWXNdKP06c0ca5BrnnLbs,17792
+clearskies/columns/belongs_to_id.py,sha256=10yImEA5xgA547kPIfRajcNwlCfXF9QTvai0-fBFxG0,17828
 clearskies/columns/belongs_to_model.py,sha256=b0eBBP6EoDEVOKP4ZZpdrD4BOadblTHzuH-KLWjOIrA,5807
 clearskies/columns/belongs_to_self.py,sha256=TbcXmRp6_OAycElrnOqaIZK5aDDheTsRoGc1M8pbAm0,3762
 clearskies/columns/boolean.py,sha256=CiYgMWvNdom8KDQk2Jt_kwWDtrLIyymrmLrP9zTYFTE,3938
@@ -138,15 +138,15 @@ clearskies/configs/writeable_model_column.py,sha256=ZwroRcvmNznggtNMSZiAmKAvllcV
 clearskies/configs/writeable_model_columns.py,sha256=D8E4aQRg1MX8-TM8lkyrWE-G_YoX2eerX4KLszgk0hA,323
 clearskies/configurable.py,sha256=FFkKwlQk17KOLnZiTsTF3hrCu2WxRSuuddNNhz9aySY,3049
 clearskies/contexts/__init__.py,sha256=f7XVUq2UKlDH6fjmcUWk6lbe9p_OaGpZ5ZjM6CuwTGQ,247
-clearskies/contexts/cli.py,sha256=HSzHieVsD3a0uQb6FBue17HVT4PjSY8LWhjW3rw7lQw,285
-clearskies/contexts/context.py,sha256=jbd8JdDkFruHiAYHZWrLjOvqz31LkvfApArCOVwkyfo,3630
-clearskies/contexts/wsgi.py,sha256=lENadrI53LYUCa3Mn4JjxhTn-53Ry9l6w2kBU3CQ5AM,611
-clearskies/contexts/wsgi_ref.py,sha256=Tkq0QYE7_ZdYvEcRKbyh-6UwwuExUadKdylwdxcCmQQ,1814
+clearskies/contexts/cli.py,sha256=Hzh8vgkLoCn2Zx8AQIoLen4fMDPIvZqtSLfEcg_CPKc,2639
+clearskies/contexts/context.py,sha256=S1iqSfV2gPnXz20-8AJU9QWh6IKa56jEV11g99iZO-o,3663
+clearskies/contexts/wsgi.py,sha256=rJCfBZhyvPyRduyY9-ctvoQMcQXwRqRGwldidiUQWBY,3111
+clearskies/contexts/wsgi_ref.py,sha256=BnV2hhusu5Hkd1cFLGXEn7COWS23u1NH9BDgAWlgX_M,2747
 clearskies/decorators.py,sha256=I91l4Iwe2swzkZPWUWywmIV2LfTBlw9IWmUfspKm3yY,1040
 clearskies/di/__init__.py,sha256=uJ1NkACEIaot7ALr3M6vQ55Pe9By_s_1z52ssAnw28E,466
 clearskies/di/additional_config.py,sha256=65INxw8aqTZQsyaKPj-aQmd6FBe4_4DwibXGgWYBy14,5139
 clearskies/di/additional_config_auto_import.py,sha256=XYw0Kcnp6hp-ee-c0YjiATwJvRb2E82xk9PuoX9dGRY,758
-clearskies/di/di.py,sha256=pWNzUDd2nxnKZP12I5SpAL3PYBWCmnM6jsT7i7cEGCM,45137
+clearskies/di/di.py,sha256=USmVkNJ7D5vDfQZiWaJ0M9hBNMZFyo8rkL_m3K2I35w,45433
 clearskies/di/inject/__init__.py,sha256=plEkWId-VyhvqX5KM2HhdCqi7_ZJzPmFz69cPAo812Y,643
 clearskies/di/inject/by_class.py,sha256=dUA_ZseLZWT30wnkg272rWwe5FzUpr0gCMMQP_HFahc,796
 clearskies/di/inject/by_name.py,sha256=oEfzeotUXPbUAiBrkE7i19nD2ISk59EEwCH3pcgSmqA,639
@@ -164,25 +164,27 @@ clearskies/di/test_module/__init__.py,sha256=7YHQF7JHP0FdI7GdEGANSZ_t1EISQYhUNm1
 clearskies/di/test_module/another_module/__init__.py,sha256=8SRmHPDepLKGWTUSc1ucDF6U8mJPsNDsBDmBQCpzPWo,35
 clearskies/di/test_module/module_class.py,sha256=I_-wnMuHfbsvti-7d2Z4bXnr6deo__uvww9nds9qrlE,46
 clearskies/end.py,sha256=Z4C9n7OvBky_640oJ8d19jIr_ap1iqjGJqqO6s_zF5g,8919
-clearskies/endpoint.py,sha256=G3oFdAYOFeYVYpMwxib6mMO5FpuF2DtrTBW04spJ-aw,48827
-clearskies/endpoint_group.py,sha256=OiGCxVyhLMORswawtYey9xLtCt4qjK8hGb9tIfPi5sc,11285
-clearskies/endpoints/__init__.py,sha256=CZJQ3rHF1GA0QvH9CKxUFM1pEnJrg-2wAj5rzIDdzjc,689
+clearskies/endpoint.py,sha256=6ihZzygVvGnBkl7IExoLbiiEPza15ULsFVtgFimZDUQ,49062
+clearskies/endpoint_group.py,sha256=evY4LbxbDj2yc_f3U4XRsci-GpWMrxOeCdoSegPSQ1o,12598
+clearskies/endpoints/__init__.py,sha256=payWNEivwmxsT-pWqNkzHisSbyNjB7oq7_I5QIQL_XA,750
 clearskies/endpoints/advanced_search.py,sha256=c1fj81nohHGqe56t00o6kLN3XIh3kfy-aKy_C1pxwgw,21835
-clearskies/endpoints/callable.py,sha256=J4XhxraxlWi09MPTh5cVJxX0iRb-xn0PIsT8wMzATQ4,13943
-clearskies/endpoints/create.py,sha256=Ex4yciWncdvu7XX__y4rmMXil-07SwPdV5rip8AKkOU,8743
-clearskies/endpoints/delete.py,sha256=voXUUs-BDhI1FqppAV6KJzsL4CLROSBMbb6gLzkNRUY,5282
-clearskies/endpoints/get.py,sha256=RRiNLDyCJdRMOVPpzKcMRNwKnaGehL-ZhDfXtOF9SNg,10368
-clearskies/endpoints/health_check.py,sha256=IRdBVR7CZts5o71dOd3qtP9U_WjHv_1tmceCocJt914,5506
-clearskies/endpoints/list.py,sha256=APek0rCtNZJScbpX6PgPE1rd3Uy5OEgZ3-bsh3LbwiI,25811
+clearskies/endpoints/callable.py,sha256=LBakZeMlhEgdB1rCgCb3vuvMYTqJr5j2l_8EdF1x3Ag,13948
+clearskies/endpoints/create.py,sha256=mk57WLexX_raAdHJJNGAYgydgkud_3VvcaMWTj8jOlQ,9015
+clearskies/endpoints/delete.py,sha256=ZKBsmpx2QC4hVKWyXkdq3tkW-BkH9uvgyTQAfuS4Bzc,5278
+clearskies/endpoints/get.py,sha256=kV7dLrj3Ph06hhyvmestqydKoNnp_32nFmxvjnh-fVc,10132
+clearskies/endpoints/health_check.py,sha256=j5ozH30xLWUMlrHhNbiHWPMoNhpNmUrdZys3bX_39kg,5540
+clearskies/endpoints/list.py,sha256=Hf1EADraDPrWSV-YgeNmpVLQ30KVzzEoB6IOpF3kH_k,25861
 clearskies/endpoints/restful_api.py,sha256=FjNYg4-qeDjjOSc8QPPFQ74SW4b_84zyQ38ck-g5pRU,16635
-clearskies/endpoints/simple_search.py,sha256=J5TT32lvimf9XgO1cGjCpK9Pjy9NjuoihS3CGlcUwrE,9714
-clearskies/endpoints/update.py,sha256=hUch9MgMhxq52AiqqI6NtxeJTOPqIfXsuZ_7XVaCjEw,7528
+clearskies/endpoints/schema.py,sha256=aMFd8WMRUD_rv3bkEbfPh31u0tAW9bchF0SVhHtqTW8,7418
+clearskies/endpoints/simple_search.py,sha256=ruifcR3efacuWm-mD3Lratunl122tHmv9TW7HVgX2P0,9710
+clearskies/endpoints/update.py,sha256=4c26WDA9Pv8p5xOosK76vxENUxXVahY3H0y1yySfUks,7855
 clearskies/environment.py,sha256=LV7XztYYUZhaL8zWXi2EC-u6DLrCPxJTeUzmCy7p-ZA,3703
-clearskies/exceptions/__init__.py,sha256=invmb0wSTpkUuPSEl49bAjU8ing8jt0vEpF2TTnvd_I,595
+clearskies/exceptions/__init__.py,sha256=eFCYGp2Pk21kKibGJvJfh2tcn_oxm4wCkR-SbWUp_EI,691
 clearskies/exceptions/authentication.py,sha256=VlNS0Aq2_6LbG0jiE8jULpS54jNW8a8px0gPrK3EZCc,42
 clearskies/exceptions/authorization.py,sha256=14JuU5zLEf2sv82VNxsJt7dGSwfP-t3Pvf_6QZuacfA,41
 clearskies/exceptions/client_error.py,sha256=o1OGnjlXT5zZ1Vb2LTRPYIio0YAnXPpXDGuqSLQP9_Y,39
 clearskies/exceptions/input_errors.py,sha256=cTEFhWKb6zGZ0NCE8s3eyjB2vZpeUVuBaFPg25ThAn0,137
+clearskies/exceptions/missing_dependency.py,sha256=mdzD35at7qM2ymht5vZYgt136Pse4ySr_DyVKcr-L2w,45
 clearskies/exceptions/moved_permanently.py,sha256=fcgU_VBtAe8ZnbyNoNpXDcTQ8UtsjdoYg4Z3Ry2gXmc,110
 clearskies/exceptions/moved_temporarily.py,sha256=Pt3muYHASvgOC50wPmoul9hUfy3Ud_NPSGFxshNWbIk,110
 clearskies/exceptions/not_found.py,sha256=_lZwovDrd18dUHDop5pF4mhexBPNr126xF2gOLA2-EA,36
@@ -191,7 +193,7 @@ clearskies/functional/routing.py,sha256=tfIvP_Y29GTGr91_1ec3LSQFoTRwpkqU4BYHXPnB
 clearskies/functional/string.py,sha256=ZnkOjx8nxqZq2TV0CIb-Kz4onGoyekTX_WkLJM6XTmM,3311
 clearskies/functional/validations.py,sha256=cPYOTwWomlQrPvqPP_Jdlds7zZ5H9GABCP5pnGzC9T4,2821
 clearskies/input_outputs/__init__.py,sha256=9qeKJULw3MQ3zqkgBZice5d7qqRgsP3y-wkhWO2Y9vM,362
-clearskies/input_outputs/cli.py,sha256=3kSE7p9OitUFyajuALwOtggJCIMIl5p_gxIby6lXE1E,6005
+clearskies/input_outputs/cli.py,sha256=_r9TNj0Z_8gDw0U_NJECuyLE89CxrHxVpXG6wT_Tt0w,6025
 clearskies/input_outputs/exceptions/__init__.py,sha256=3KiM3KaMYEKoToqCCQ4_no2n0W5ROqeBC0sI2Ix4P6w,82
 clearskies/input_outputs/exceptions/cli_input_error.py,sha256=kOFU8aLTLmeTL_AKDshxMu8_ufildg6p8ndhE1xHfb0,41
 clearskies/input_outputs/exceptions/cli_not_found.py,sha256=JBBuZA9ZwdkPhd3a0qaGgEPQrxh1fehy4R3ZaV2gWXU,39
@@ -200,7 +202,7 @@ clearskies/input_outputs/input_output.py,sha256=W5h8a9XFEqwi3h6v17okblz8sOozUj-m
 clearskies/input_outputs/programmatic.py,sha256=gfsNFIfiF5cvxi1aS9SgArcKYUgkL5gyxjCMQLwgivY,1711
 clearskies/input_outputs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clearskies/input_outputs/wsgi.py,sha256=94tgWxiwpwvJA9G4nG-hCHteg0pq9pIDCVhnheZuAQc,2544
-clearskies/model.py,sha256=MMeoMvwH_Ijca0hLxEf0f8UTczzliu1Lj91CxYOHogg,73385
+clearskies/model.py,sha256=6ZJoWNKzjsQFvgXEaXybrO0HaaknoSkKYNYO_i0Ep0k,77189
 clearskies/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clearskies/query/__init__.py,sha256=ISF80_cG3rd574sRTdKKPxAdlSjtQh_ClXKKs_MSSSo,277
 clearskies/query/condition.py,sha256=9RJrYya1Kfzx0L_BMDKQhYkN9dB7NAq5kRK5mz51YdY,8624
@@ -243,7 +245,7 @@ clearskies/validators/minimum_value.py,sha256=Vz0e_9U5KYqBGqfrVBOtPiVtmNPWwFEGPA
 clearskies/validators/required.py,sha256=f8VE9sbvIorTIC0q_77DyDfDjAJYFJs-uTgJkAwLxX4,1362
 clearskies/validators/timedelta.py,sha256=nFEHefllfMZsguJoSdeWzaBsxBDZfMZoIdt5jZxeg0g,1932
 clearskies/validators/unique.py,sha256=DZA7dbLucYDShtr1bVP2pnmbzciIEMvYSrTjOKCQ4vM,1029
-clear_skies-2.0.2.dist-info/LICENSE,sha256=3Ehd0g3YOpCj8sqj0Xjq5qbOtjjgk9qzhhD9YjRQgOA,1053
-clear_skies-2.0.2.dist-info/METADATA,sha256=jsf2tuLi8kFkZmJENAnP9AIfNC-k_7spE1xaXXaLw0M,1762
-clear_skies-2.0.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-clear_skies-2.0.2.dist-info/RECORD,,
+clear_skies-2.0.4.dist-info/LICENSE,sha256=3Ehd0g3YOpCj8sqj0Xjq5qbOtjjgk9qzhhD9YjRQgOA,1053
+clear_skies-2.0.4.dist-info/METADATA,sha256=Yg6lHe70x40QvQ0qI29YvfirIi48-vv-WcHu7cQ-77A,1625
+clear_skies-2.0.4.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+clear_skies-2.0.4.dist-info/RECORD,,

clearskies/__init__.py

@@ -10,6 +10,7 @@ from . import (
     endpoints,
     exceptions,
     functional,
+    input_outputs,
     query,
     # secrets,
     security_headers,
@@ -39,6 +40,7 @@ __all__ = [
     "Configurable",
     "contexts",
     "di",
+    "input_outputs",
     "End",
     "Endpoint",
     "EndpointGroup",

clearskies/autodoc/formats/oai3_json/__init__.py

@@ -1,7 +1,7 @@
-from .oai3_json import OAI3JSON
+from .oai3_json import Oai3Json
 from .oai3_schema_resolver import OAI3SchemaResolver
 
 __all__ = [
     "OAI3SchemaResolver",
-    "OAI3JSON",
+    "Oai3Json",
 ]

clearskies/autodoc/formats/oai3_json/oai3_json.py

@@ -4,7 +4,7 @@ from typing import Any
 from .request import Request
 
 
-class OAI3JSON:
+class Oai3Json:
     requests: Any = None
     formatted: Any = None
     models: Any = None
@@ -67,7 +67,7 @@ class OAI3JSON:
             path_data = request.convert()
             for request_method, path_doc in path_data.items():
                 if request_method in paths[absolute_path]:
-                    raise ValueError(f"Two routes had the same path and method: {absolute_path} - {request_method}")
+                    continue
                 paths[absolute_path][request_method] = path_doc
 
         data: dict[str, Any] = {

clearskies/autodoc/formats/oai3_json/schema/object.py

@@ -4,6 +4,12 @@ from typing import Any
 class Object:
     def __init__(self, schema, oai3_schema_resolver):
         self.schema = schema
+        # shhhh
+        self.schema.children = [
+            child[0] if (isinstance(child, tuple) or isinstance(child, list)) else child
+            for child in self.schema.children
+        ]
+
         self.oai3_schema_resolver = oai3_schema_resolver
 
     def convert(self, include_required=False):

clearskies/autodoc/request/request.py

@@ -1,3 +1,4 @@
+import re
 from typing import Any
 
 
@@ -12,6 +13,14 @@ class Request:
     def __init__(
         self, description, responses, relative_path="", request_methods="GET", parameters=None, root_properties=None
     ):
+        # clearskies supports path parameters via {parameter} and :parameter but we want to normalize to {paramter} for
+        # autodoc purposes
+        if ":" in relative_path:
+            relative_path = "/" + relative_path.strip("/") + "/"
+            for match in re.findall("/(:[^/]+)/", relative_path):
+                name = match[1:]
+                relative_path = relative_path.replace(f"/:{name}/", "/{" + name + "}/")
+
         self.description = description
         self.responses = responses
         self.relative_path = relative_path.lstrip("/")

clearskies/backends/backend.py

@@ -10,7 +10,7 @@ from clearskies.autodoc.schema import Schema as AutoDocSchema
 
 class Backend(ABC):
     """
-    Conecting models to their data since 2020!
+    Connecting models to their data since 2020!.
 
     The backend system acts as a flexible layer between models and their data sources.  By changing the backend attached to a model,
     you change where the model fetches and saves data.  This might be a database, an in-memory data store, a dynamodb table,

clearskies/columns/belongs_to_id.py

@@ -356,11 +356,11 @@ class BelongsToId(String):
         parent_model = self.parent_model
         matching_parents = parent_model.where(f"{parent_model.id_column_name}={value}")
         matching_parents = self.apply_wheres(matching_parents)
-        matching_parents = matching_parents.where_for_request(
+        matching_parents = matching_parents.where_for_request_all(
             matching_parents,
-            self.input_output.routing_data,
-            self.input_output.authorization_data,
             self.input_output,
+            routing_data=self.input_output.routing_data,
+            authorization_data=self.input_output.authorization_data,
         )
         if not len(matching_parents):
             return f"Invalid selection for {self.name}: record does not exist"

clearskies/contexts/cli.py

@@ -5,6 +5,112 @@ from clearskies.input_outputs import Cli as CliInputOutput
 class Cli(Context):
     """
     Run an application via a CLI command
+
+    This context converts a clearskies application into a CLI command.  Here's a simple example:
+
+    ```
+    #!/usr/bin/env python
+    import clearskies
+
+    def my_function():
+        return "Hello World!"
+
+    cli = clearskies.contexts.Cli(my_function)
+    cli()
+    ```
+
+    Which you can then run as expected:
+
+    ```
+    $ ./example.py
+    Hello World!
+    ```
+
+    Routing is still supported, with routes and route parameters becoming CLI args:
+
+    ```
+    #!/usr/bin/env python
+    import clearskies
+
+    def my_function(name):
+        return f"Hello {name}!"
+
+    cli = clearskies.contexts.Cli(
+        clearskies.endpoints.Callable(
+            my_function,
+            url="/hello/:name",
+            return_standard_response=False,
+        )
+    )
+    cli()
+    ```
+
+    With a url of `/hello/:name` you would invoke like so:
+
+    ```
+    ./example.py hello Bob
+    Hello Bob!
+    ```
+
+    If the endpoint expects a request method you can provide it by setting the `-X` or `--request_method=`
+    kwargs.  So for tihs example:
+
+    ```
+    #!/usr/bin/env python
+    import clearskies
+
+    def my_function(name):
+        return f"Hello {name}!"
+
+    cli = clearskies.contexts.Cli(
+        clearskies.endpoints.Callable(
+            my_function,
+            url="/hello/:name",
+            request_methods=["POST"],
+        )
+    )
+    cli()
+    ```
+
+    And then calling it successfully:
+
+    ```
+    ./example.py hello Bob --request_method=POST
+
+    ./example.py hello Bob -X POST
+    ```
+
+    You can pass data as a json string with the -d flag or set individual named arguments.  The following
+    example just reflects the request data back to the client:
+
+    ```
+    #!/usr/bin/env python
+    import clearskies
+
+    def my_function(request_data):
+        return request_data
+
+    cli = clearskies.contexts.Cli(
+        clearskies.endpoints.Callable(
+            my_function,
+        )
+    )
+    cli()
+    ```
+
+    And these three calls are identical:
+
+    ```
+    ./example.py -d '{"hello": "world"}'
+
+    echo '{"hello": "world"}' | ./test.py
+
+    ./test.py --hello=world
+    ```
+
+    Although note that the first two are going to be preferred over the third, simply because with the
+    third there's simply no way to specify the type of a variable.  As a result, you may run into issues
+    with strict type checking on endpoints.
     """
 
     def __call__(self):  # type: ignore

clearskies/contexts/context.py

@@ -48,6 +48,7 @@ class Context:
             bindings=bindings,
             additional_configs=additional_configs,
             class_overrides=class_overrides,
+            overrides=overrides,
             now=now,
             utcnow=utcnow,
         )

clearskies/contexts/wsgi.py

@@ -14,6 +14,62 @@ from clearskies.input_outputs import Wsgi as WsgiInputOutput
 class Wsgi(Context):
     """
     Connect your application to a WSGI server.
+
+    The Wsgi context is used to connect a clearskies application to a WSGI server of your choice.  As with all
+    contexts, you first create it and pass in the application (a callable, endpoint, or endpoint group) as well
+    as any dependency injection parameters.  Then, you call the context from inside of the function invoked by
+    your WSGI server, passing along the `environment` and `start_response` variables, and returning the response
+    from the context.  Here's a simple example:
+
+    ```
+    import clearskies
+
+    def hello_world():
+        return "Hello World!"
+
+    wsgi = clearskies.contexts.Wsgi(hello_world)
+
+    def application(environment, start_response):
+        return wsgi(environment, start_response)
+    ```
+
+    You would then launch your WSGI server.  For instance, here's how to launch it with uwsgi, which automatically
+    looks for a function called `application` and treats that as the WSGI starting point:
+
+    ```
+    uwsgi --http :9090 --wsgi-file test.py
+    ```
+
+    You could then:
+
+    ```
+    curl 'http://localhost:9090'
+    ```
+
+    And see the response from this "hello world" app.  Note than in the above example I create the context outside
+    of the application function.  Of course, you can do the opposite:
+
+    ```
+    import clearskies
+
+    def hello_world():
+        return "Hello World!"
+
+    def application(environment, start_response):
+        wsgi = clearskies.contexts.Wsgi(hello_world)
+        return wsgi(environment, start_response)
+    ```
+
+    The difference is that most wsgi servers will cache any objects created outside of the handler function (e.g. `application`
+    in this case).  When you first create the context clearskies will configure and validate any endpoints attached.
+    Also, it will create an instance of the dependency injection container and cache it.  If the context object is created
+    outside of the handler, and the server caches objects in this csae, then this validation will only happen once and
+    the DI cache will store objects in between HTTP calls.  If you create your context inside the handler function, then
+    you'll end up with an empty cache everytime and you'll have slower responses because of clearskies checking the
+    application configuration everytime.  Note that the DI system for clearskies grants you full cache control, so
+    by and large it's normal and expected that you'll persist the cache between requests by creating the context outside
+    of any handler functions.
+
     """
 
     def __call__(self, env, start_response):  # type: ignore

clearskies/contexts/wsgi_ref.py

@@ -14,6 +14,35 @@ from clearskies.input_outputs import Wsgi as WsgiInputOutput
 class WsgiRef(Context):
     """
     Use a built in WSGI server (for development purposes only).
+
+    This context will launch a built-in HTTP server for you, so you can run applications locally
+    without having to install extra dependencies.  Note that this server is not intended for production
+    usage, so this is best used for simple tests/demonstration purposes.  Unlike the WSGI context, where
+    you define the application handler and invoke the context from inside of it (passing along the
+    environment and start_response variables), in this case you simply directly invoke the context to
+    launch the server.  The default port is 8080:
+
+    ```
+    #!/usr/bin/env python
+    import clearskies
+
+    def hello_world(name):
+        return f"Hello {name}!"
+
+    wsgi = clearskies.contexts.WsgiRef(
+        clearskies.endpoints.Callable(
+            hello_world,
+            url="/hello/:name",
+        )
+    )
+    wsgi()
+    ```
+
+    And to invoke it:
+
+    ```
+    curl 'http://localhost:8080/hello/Friend'
+    ```
     """
 
     port: int = 8080

clearskies/di/di.py

@@ -15,6 +15,7 @@ import clearskies.secrets
 from clearskies.di.additional_config import AdditionalConfig
 from clearskies.di.additional_config_auto_import import AdditionalConfigAutoImport
 from clearskies.environment import Environment
+from clearskies.exceptions import MissingDependency
 from clearskies.functional import string
 
 
@@ -83,6 +84,7 @@ class Di:
     | connection_details   | -                                                       | A dictionary containing credentials that pymysql should use when connecting to a database |
     | connection           | -                                                       | A pymysql connection object                                                               |
     | cursor               | -                                                       | A pymysql cursor object                                                                   |
+    | endpoint_groups      | -                                                       | The list of endpoint groups handling the request                                          |
 
     Note: for dependencies with an injection name but no injection type, this means that to inject those values you
     must name your argument with the given injection name.  In all of the above cases though you can still add type
@@ -635,7 +637,7 @@ class Di:
             return self._prepared[name]
 
         context_note = f" for {context}" if context else ""
-        raise ValueError(
+        raise MissingDependency(
             f"I was asked to build {name}{context_note} but there is no added class, configured binding, "
             + f"or a corresponding 'provide_{name}' method for this name."
         )
@@ -966,3 +968,6 @@ class Di:
         import akeyless  # type: ignore
 
         return akeyless
+
+    def provide_endpoint_groups(self):
+        return []

clearskies/endpoint.py

@@ -963,11 +963,11 @@ class Endpoint(
                 model = self.di.call_function(where, model=model, **input_output.get_context_for_callables())
             else:
                 model = model.where(where)
-        model = model.where_for_request(
+        model = model.where_for_request_all(
             model,
+            input_output,
             input_output.routing_data,
             input_output.authorization_data,
-            input_output,
             overrides=self.column_overrides,
         )
         return self.authorization.filter_model(model, input_output.authorization_data, input_output)
@@ -1261,8 +1261,9 @@ class Endpoint(
     ) -> list[schema.Schema]:
         if schema is None:
             schema = self.model_class
-        if column_names is None and self.readable_column_names:
-            readable_column_names: list[str] = self.readable_column_names
+        readable_column_names = [*column_names]
+        if not readable_column_names and self.readable_column_names:
+            readable_column_names: list[str] = self.readable_column_names  # type: ignore
         properties = []
 
         columns = schema.get_columns()
@@ -1289,16 +1290,19 @@ class Endpoint(
 
         model_name = string.camel_case_to_snake_case(schema.__name__)
         columns = schema.get_columns()
-        return [
-            autodoc.request.JSONBody(
-                columns[column_name].documentation(name=self.auto_case_column_name(column_name, True)),
-                description=f"Set '{column_name}' for the {model_name}",
-                required=columns[column_name].is_required,
+        parameters = []
+        for column_name in column_names:
+            columns[column_name].injectable_properties(self.di)
+            parameters.append(
+                autodoc.request.JSONBody(
+                    columns[column_name].documentation(name=self.auto_case_column_name(column_name, True)),
+                    description=f"Set '{column_name}' for the {model_name}",
+                    required=columns[column_name].is_required,
+                )
             )
-            for column_name in column_names
-        ]
+        return parameters  # type: ignore
 
-    def standard_url_request_parameters(self) -> list[Parameter]:
+    def documentation_url_parameters(self) -> list[Parameter]:
         parameter_names = routing.extract_url_parameter_name_map(self.url.strip("/"))
         return [
             autodoc.request.URLPath(

clearskies/endpoint_group.py

@@ -230,6 +230,8 @@ class EndpointGroup(
     """
     endpoints = clearskies.configs.EndpointList()
 
+    internal_casing = clearskies.configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
+    external_casing = clearskies.configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
     response_headers = clearskies.configs.StringListOrCallable(default=[])
     authentication = clearskies.configs.Authentication(default=Public())
     authorization = clearskies.configs.Authorization(default=Authorization())
@@ -238,6 +240,8 @@ class EndpointGroup(
     cors_header: SecurityHeader = None  # type: ignore
     has_cors: bool = False
     endpoints_initialized = False
+    external_casing = "snake_case"
+    internal_casing = "snake_case"
 
     @clearskies.decorators.parameters_to_properties
     def __init__(
@@ -246,6 +250,8 @@ class EndpointGroup(
         url: str = "",
         response_headers: list[str | Callable[..., list[str]]] = [],
         security_headers: list[SecurityHeader] = [],
+        internal_casing: str = "snake_case",
+        external_casing: str = "snake_case",
         authentication: Authentication = Public(),
         authorization: Authorization = Authorization(),
     ):
@@ -273,6 +279,11 @@ class EndpointGroup(
             if self.url.strip("/"):
                 endpoint.add_url_prefix(self.url)
 
+    def add_url_prefix(self, prefix: str) -> None:
+        self.url = (prefix.rstrip("/") + "/" + self.url.lstrip("/")).lstrip("/")
+        for endpoint in self.endpoints:
+            endpoint.add_url_prefix(self.url)
+
     def matches_request(self, input_output: InputOutput, allow_partial=True) -> bool:
         """Whether or not we can handle an incoming request based on URL and request method."""
         expected_url = self.url.strip("/")
@@ -303,8 +314,25 @@ class EndpointGroup(
             return self.error(input_output, "Not Found", 404)
 
         self.add_response_headers(input_output)
+
+        # "register" ourself with the DI system
+        current_endpoint_groups = self.di.build_from_name("endpoint_groups", cache=True)
+        current_endpoint_groups.append(self)
+        self.di.add_binding("endpoint_groups", current_endpoint_groups)
+
         return endpoint(input_output)
 
     def error(self, input_output: InputOutput, message: str, status_code: int) -> Any:
         """Return a client-side error (e.g. 400)."""
         return self.respond_json(input_output, {"status": "client_error", "error": message}, status_code)
+
+    def all_endpoints(self) -> list[Endpoint]:
+        """Returns the full (recursive) list of all endpoints associated with this endpoint group"""
+        all_endpoints: list[Endpoint] = []
+        for endpoint in self.endpoints:
+            if hasattr(endpoint, "all_endpoints"):
+                all_endpoints = [*all_endpoints, *endpoint.all_endpoints()]
+            else:
+                all_endpoints.append(endpoint)
+
+        return all_endpoints

clearskies/endpoints/__init__.py

@@ -6,6 +6,7 @@ from clearskies.endpoints.get import Get
 from clearskies.endpoints.health_check import HealthCheck
 from clearskies.endpoints.list import List
 from clearskies.endpoints.restful_api import RestfulApi
+from clearskies.endpoints.schema import Schema
 from clearskies.endpoints.simple_search import SimpleSearch
 from clearskies.endpoints.update import Update
 
@@ -18,6 +19,7 @@ __all__ = [
     "HealthCheck",
     "List",
     "RestfulApi",
+    "Schema",
     "SimpleSearch",
     "Update",
 ]

clearskies/endpoints/callable.py

@@ -359,7 +359,7 @@ class Callable(Endpoint):
                 request_methods=self.request_methods,
                 parameters=[
                     *self.documentation_request_parameters(),
-                    *self.standard_url_parameters(),
+                    *self.documentation_url_parameters(),
                 ],
                 root_properties={
                     "security": self.documentation_request_security(),

clearskies/endpoints/create.py

@@ -155,7 +155,11 @@ class Create(Endpoint):
         )
 
         authentication = self.authentication
-        standard_error_responses = [self.documentation_input_error_response()]
+        # Many swagger UIs will only allow one response per status code, and we use the same status code (200)
+        # for both a success response and an input error response.  This could be fixed by changing the status
+        # code for input error responses, but there's not actually a great HTTP status code for that, so :shrug:
+        # standard_error_responses = [self.documentation_input_error_response()]
+        standard_error_responses = []
         if not getattr(authentication, "is_public", False):
             standard_error_responses.append(self.documentation_access_denied_response())
             if getattr(authentication, "can_authorize", False):
@@ -176,7 +180,7 @@ class Create(Endpoint):
                 request_methods=self.request_methods,
                 parameters=[
                     *self.documentation_request_parameters(),
-                    *self.standard_url_parameters(),
+                    *self.documentation_url_parameters(),
                 ],
                 root_properties={
                     "security": self.documentation_request_security(),
@@ -187,7 +191,6 @@ class Create(Endpoint):
     def documentation_request_parameters(self) -> list[autodoc.request.Parameter]:
         return [
             *self.standard_json_request_parameters(self.model_class),
-            *(self.standard_url_request_parameters() if self.include_routing_data_in_request_data else []),
         ]
 
     def documentation_models(self) -> dict[str, autodoc.schema.Schema]:

clearskies/endpoints/delete.py

@@ -127,7 +127,7 @@ class Delete(Get):
                 relative_path=self.url,
                 request_methods=self.request_methods,
                 parameters=[
-                    *self.documentation_routing_parameters(),
+                    *self.documentation_url_parameters(),
                 ],
                 root_properties={
                     "security": self.documentation_request_security(),

clearskies/endpoints/get.py

@@ -231,7 +231,7 @@ class Get(Endpoint):
         )
 
         authentication = self.authentication
-        standard_error_responses = [self.documentation_input_error_response()]
+        standard_error_responses = []
         if not getattr(authentication, "is_public", False):
             standard_error_responses.append(self.documentation_access_denied_response())
             if getattr(authentication, "can_authorize", False):
@@ -251,8 +251,7 @@ class Get(Endpoint):
                 relative_path=self.url,
                 request_methods=self.request_methods,
                 parameters=[
-                    *self.documentation_routing_parameters(),
-                    *self.standard_url_parameters(),
+                    *self.documentation_url_parameters(),
                 ],
                 root_properties={
                     "security": self.documentation_request_security(),
@@ -260,9 +259,6 @@ class Get(Endpoint):
             ),
         ]
 
-    def documentation_routing_parameters(self) -> list[autodoc.request.Parameter]:
-        return self.standard_url_request_parameters()
-
     def documentation_models(self) -> dict[str, autodoc.schema.Schema]:
         output_schema = self.output_schema if self.output_schema else self.model_class
         schema_model_name = string.camel_case_to_snake_case(output_schema.__name__)

clearskies/endpoints/health_check.py

@@ -162,7 +162,6 @@ class HealthCheck(Endpoint):
 
     def documentation(self) -> list[autodoc.request.Request]:
         output_schema = self.model_class
-        nice_model = string.camel_case_to_words(output_schema.__name__)
         output_autodoc = (autodoc.schema.Object(self.auto_case_internal_column_name("data"), children=[]),)
 
         description = self.description if self.description else "Health Check"
@@ -177,5 +176,8 @@ class HealthCheck(Endpoint):
                 ],
                 relative_path=self.url,
                 request_methods=self.request_methods,
+                parameters=[
+                    *self.documentation_url_parameters(),
+                ],
             ),
         ]

clearskies/endpoints/list.py

@@ -476,6 +476,7 @@ class List(Endpoint):
             *self.documentation_url_sort_parameters(),
             *self.documentation_url_search_parameters(),
             *self.documentation_json_search_parameters(),
+            *self.documentation_url_parameters(),
         ]
 
     def documentation_models(self) -> dict[str, autodoc.schema.Schema]:

clearskies/endpoints/schema.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import inspect
+from collections import OrderedDict
+from typing import TYPE_CHECKING, Any, Callable, Type
+
+import clearskies.autodoc
+import clearskies.configs
+import clearskies.exceptions
+from clearskies import authentication, autodoc, typing
+from clearskies.authentication import Authentication, Authorization
+from clearskies.endpoint import Endpoint
+from clearskies.input_outputs import InputOutput
+
+if TYPE_CHECKING:
+    from clearskies import Column, SecurityHeader
+    from clearskies.model import Model
+
+
+class Schema(Endpoint):
+    """
+    An endpoint that automatically creates a swagger doc for the application
+
+    The schema endpoint must always be attached to an endpoint group.  It will document all endpoints
+    attached to its parent endpoint group.
+
+    Keep in mind that the routing in the endpoint group is greedy and goes from top-down.  As a result,
+    since the schema endpoint (typically) has a specific URL, it's usually best for it to be at the top
+    of your endpoint list.  The following example builds an application with two endpoint groups, each
+    of which has a schema endpoint:
+
+    ```
+    import clearskies
+    from clearskies.validators import Required, Unique
+    from clearskies import columns
+
+
+    class User(clearskies.Model):
+        id_column_name = "id"
+        backend = clearskies.backends.MemoryBackend()
+
+        id = columns.Uuid()
+        name = columns.String(validators=[Required()])
+        username = columns.String(
+            validators=[
+                Required(),
+                Unique(),
+            ]
+        )
+        age = columns.Integer(validators=[Required()])
+        company_name = columns.String()
+        created_at = columns.Created()
+        updated_at = columns.Updated()
+
+
+    readable_column_names = [
+        "id",
+        "name",
+        "username",
+        "age",
+        "company_name",
+        "created_at",
+        "updated_at",
+    ]
+    writeable_user_column_names = ["name", "username", "age", "company_name"]
+    users_api = clearskies.EndpointGroup(
+        [
+            clearskies.endpoints.Schema(url="schema"),
+            clearskies.endpoints.RestfulApi(
+                url="users",
+                model_class=User,
+                readable_column_names=readable_column_names,
+                writeable_column_names=writeable_user_column_names,
+                sortable_column_names=readable_column_names,
+                searchable_column_names=readable_column_names,
+                default_sort_column_name="name",
+            )
+        ],
+        url="/users",
+    )
+
+    class SomeThing(clearskies.Model):
+        id_column_name = "id"
+        backend = clearskies.backends.MemoryBackend()
+
+        id = clearskies.columns.Uuid()
+        thing_1 = clearskies.columns.String(validators=[Required()])
+        thing_2 = clearskies.columns.String(validators=[Unique()])
+
+    more_endpoints = clearskies.EndpointGroup(
+        [
+            clearskies.endpoints.HealthCheck(url="health"),
+            clearskies.endpoints.Schema(url="schema"),
+            clearskies.endpoints.Callable(
+                lambda request_data, some_things: some_things.create(request_data),
+                model_class=SomeThing,
+                readable_column_names=["id", "thing_1", "thing_2"],
+                writeable_column_names=["thing_1", "thing_2"],
+                request_methods=["POST"],
+                url="some_thing",
+            ),
+            users_api,
+        ]
+    )
+
+    wsgi = clearskies.contexts.WsgiRef(more_endpoints)
+    wsgi()
+    ```
+
+    We attach the `more_endpoints` endpoint group to our context, and this contains 4 endpoints:
+
+     1. A healthcheck
+     2. A schema endpoint
+     3. A callable endpoint
+     4. The `users_api` endpoint group.
+
+    The `users_api` endpoint group then contains it's own schema endpoint and a restful api endpoint
+    with all our standard user CRUD operations.  As a result, we can fetch two different schema endpoints:
+
+    ```
+    curl 'http://localhost/schema'
+
+    curl 'http://localhost/users/schema'
+    ```
+
+    The former documents all endpoints in the system.  The latter only documents the endpoints under the `/users`
+    path provided by the `users_api` endpoint group.
+    """
+
+    """
+    The doc builder class/format to use
+    """
+    schema_format = clearskies.configs.Any(default=clearskies.autodoc.formats.oai3_json.Oai3Json)
+
+    """
+    Addiional data to inject into the schema doc.
+
+    This is typically used for setting info/server settings in the resultant swagger doc.  Anything
+    in this dictionary is injected into the "root" of the generated documentation file.
+    """
+    schema_configuration = clearskies.configs.AnyDict(default={})
+
+    @clearskies.decorators.parameters_to_properties
+    def __init__(
+        self,
+        url: str,
+        schema_format=clearskies.autodoc.formats.oai3_json.Oai3Json,
+        request_methods: list[str] = ["GET"],
+        response_headers: list[str | Callable[..., list[str]]] = [],
+        security_headers: list[SecurityHeader] = [],
+        schema_configuration: dict[str, Any] = {},
+        authentication: Authentication = authentication.Public(),
+    ):
+        # we need to call the parent but don't have to pass along any of our kwargs.  They are all optional in our parent, and our parent class
+        # just stores them in parameters, which we have already done.  However, the parent does do some extra initialization stuff that we need,
+        # which is why we have to call the parent.
+        super().__init__()
+
+    def handle(self, input_output: InputOutput) -> Any:
+        current_endpoint_groups = self.di.build_from_name("endpoint_groups", cache=True)
+        if not current_endpoint_groups:
+            raise ValueError(
+                f"{self.__class__.__name__} endpoint was attached directly to the context, but it must be attached to an endpoint group (otherwise it has no application to document)."
+            )
+
+        # the endpoint group at the end of the list is the one that invoked us.  Let's grab it
+        # if we don't hvae any endpoint groups then we've been attached directly to a context,
+        # which is pointless - there's nothing for us to document.  So, treat it as an error.
+        endpoint_group = current_endpoint_groups[-1]
+        requests: list[Any] = []
+        models: dict[str, Any] = {}
+        security_schemes: dict[str, Any] = {}
+        for endpoint in endpoint_group.all_endpoints():
+            requests.extend(endpoint.documentation())
+            models = {**models, **endpoint.documentation_models()}
+            # if "user" in models:
+            # print(models["user"].children)
+            # print(endpoint.__class__.__name__)
+            security_schemes = {**security_schemes, **endpoint.documentation_security_schemes()}
+        # print(models["user"].children)
+
+        schema = self.di.build(self.schema_format)
+        schema.set_requests(requests)
+        schema.set_components({"models": models, "securitySchemes": security_schemes})
+        extra_schema_config = {**self.schema_configuration}
+        if "info" not in extra_schema_config:
+            extra_schema_config["info"] = {"title": "Auto generated by clearskies", "version": "1.0"}
+        self.add_response_headers(input_output)
+        return input_output.respond(schema.pretty(root_properties=extra_schema_config), 200)

clearskies/endpoints/simple_search.py

@@ -274,8 +274,8 @@ class SimpleSearch(List):
 
     def documentation_url_search_parameters(self) -> list[autodoc.request.Parameter]:
         docs = []
-        for column in self._get_searchable_columns().values():
-            column_doc = column.documentation()
+        for column in self.searchable_columns.values():
+            column_doc = column.documentation()[0]
             column_doc.name = self.auto_case_internal_column_name(column_doc.name)
             docs.append(
                 autodoc.request.URLParameter(

clearskies/endpoints/update.py

@@ -143,7 +143,11 @@ class Update(Get):
         )
 
         authentication = self.authentication
-        standard_error_responses = [self.documentation_input_error_response()]
+        # Many swagger UIs will only allow one response per status code, and we use the same status code (200)
+        # for both a success response and an input error response.  This could be fixed by changing the status
+        # code for input error responses, but there's not actually a great HTTP status code for that, so :shrug:
+        # standard_error_responses = [self.documentation_input_error_response()]
+        standard_error_responses = []
         if not getattr(authentication, "is_public", False):
             standard_error_responses.append(self.documentation_access_denied_response())
             if getattr(authentication, "can_authorize", False):
@@ -164,7 +168,7 @@ class Update(Get):
                 request_methods=self.request_methods,
                 parameters=[
                     *self.documentation_request_parameters(),
-                    *self.standard_url_parameters(),
+                    *self.documentation_url_parameters(),
                 ],
                 root_properties={
                     "security": self.documentation_request_security(),
@@ -175,7 +179,6 @@ class Update(Get):
     def documentation_request_parameters(self) -> list[autodoc.request.Parameter]:
         return [
             *self.standard_json_request_parameters(self.model_class),
-            *self.standard_url_request_parameters(),
         ]
 
     def documentation_models(self) -> dict[str, autodoc.schema.Schema]:

clearskies/exceptions/__init__.py

@@ -2,6 +2,7 @@ from clearskies.exceptions.authentication import Authentication
 from clearskies.exceptions.authorization import Authorization
 from clearskies.exceptions.client_error import ClientError
 from clearskies.exceptions.input_errors import InputErrors
+from clearskies.exceptions.missing_dependency import MissingDependency
 from clearskies.exceptions.moved_permanently import MovedPermanently
 from clearskies.exceptions.moved_temporarily import MovedTemporarily
 from clearskies.exceptions.not_found import NotFound
@@ -11,6 +12,7 @@ __all__ = [
     "Authorization",
     "ClientError",
     "InputErrors",
+    "MissingDependency",
     "MovedPermanently",
     "MovedTemporarily",
     "NotFound",

clearskies/exceptions/missing_dependency.py

@@ -0,0 +1,2 @@
+class MissingDependency(Exception):
+    pass

clearskies/input_outputs/cli.py

@@ -20,12 +20,13 @@ class Cli(InputOutput):
         super().__init__()
 
     def respond(self, response, status_code=200):
-        if status_code != 200:
-            sys.exit(response)
         if type(response) != str:
-            print(json.dumps(response))
+            final = json.dumps(response)
         else:
-            print(response)
+            final = response
+        if status_code != 200:
+            sys.exit(final)
+        print(final)
 
     def get_arguments(self):
         return sys.argv

clearskies/model.py

@@ -983,6 +983,48 @@ class Model(Schema, InjectableProperties):
         It has no retrun value and is passed no data.  By the time this fires the model has already been
         updated with the new data.  You can decide on the necessary actions using the `was_changed` and
         the `previous_value` functions.
+
+        ```
+        from typing import Any, Self
+        import clearskies
+
+        class History(clearskies.Model):
+            id_column_name = "id"
+            backend = clearskies.backends.MemoryBackend()
+
+            id = clearskies.columns.Uuid()
+            message = clearskies.columns.String()
+            created_at = clearskies.columns.Created(date_format="%Y-%m-%d %H:%M:%S.%f")
+
+        class User(clearskies.Model):
+            id_column_name = "id"
+            backend = clearskies.backends.MemoryBackend()
+            histories = clearskies.di.inject.ByClass(History)
+
+            id = clearskies.columns.Uuid()
+            age = clearskies.columns.Integer()
+            name = clearskies.columns.String()
+
+            def save_finished(self: Self) -> None:
+                if not self.was_changed("age"):
+                    return
+
+                self.histories.create({"message": f"My name is {self.name} and I am {self.age} years old"})
+
+        def my_application(users, histories):
+            jane = users.create({"name": "Jane"})
+            jane.save({"age": 25})
+            jane.save({"age": 26})
+            jane.save({"age": 30})
+
+            return [history.message for history in histories.sort_by("created_at", "ASC")]
+
+        cli = clearskies.contexts.Cli(
+            my_application,
+            classes=[User, History],
+        )
+        cli()
+        ```
         """
         pass
 
@@ -1004,18 +1046,86 @@ class Model(Schema, InjectableProperties):
         """Create a hook to extend so you can provide additional post-delete logic as needed."""
         pass
 
-    def where_for_request(
+    def where_for_request_all(
         self: Self,
-        models: Self,
+        model: Self,
+        input_output: Any,
         routing_data: dict[str, str],
         authorization_data: dict[str, Any],
-        input_output: Any,
         overrides: dict[str, Column] = {},
     ) -> Self:
-        """Create a hook to automatically apply filtering whenever the model makes an appearance in a get/update/list/search handler."""
+        """
+        A hook to automatically apply filtering whenever the model makes an appearance in a get/update/list/search handler.
+        """
         for column in self.get_columns(overrides=overrides).values():
-            models = column.where_for_request(models, routing_data, authorization_data, input_output)  # type: ignore
-        return models
+            models = column.where_for_request(model, input_output, routing_data, authorization_data)  # type: ignore
+        return self.where_for_request(
+            model, input_output, routing_data=routing_data, authorization_data=authorization_data, overrides=overrides
+        )
+
+    def where_for_request(
+        self: Self,
+        model: Self,
+        input_output: Any,
+        routing_data: dict[str, str],
+        authorization_data: dict[str, Any],
+        overrides: dict[str, Column] = {},
+    ) -> Self:
+        """
+        A hook to automatically apply filtering whenever the model makes an appearance in a get/update/list/search handler.
+
+        Note that this automatically affects the behavior of the various list endpoints, but won't be called when you create your
+        own queries directly.  Here's an example where the model restricts the list endpoint so that it only returns users with
+        an age over 18:
+
+        ```
+        from typing import Any, Self
+        import clearskies
+
+        class User(clearskies.Model):
+            id_column_name = "id"
+            backend = clearskies.backends.MemoryBackend()
+            id = clearskies.columns.Uuid()
+            name = clearskies.columns.String()
+            age = clearskies.columns.Integer()
+
+            def where_for_request(
+                self: Self,
+                model: Self,
+                input_output: Any,
+                routing_data: dict[str, str],
+                authorization_data: dict[str, Any],
+                overrides: dict[str, clearskies.Column] = {},
+            ) -> Self:
+                return model.where("age>=18")
+
+        list_users = clearskies.endpoints.List(
+            model_class=User,
+            readable_column_names=["id", "name", "age"],
+            sortable_column_names=["id", "name", "age"],
+            default_sort_column_name="name",
+        )
+
+        wsgi = clearskies.contexts.WsgiRef(
+            list_users,
+            classes=[User],
+            bindings={
+                "memory_backend_default_data": [
+                    {
+                        "model_class": User,
+                        "records": [
+                            {"id": "1-2-3-4", "name": "Bob", "age": 20},
+                            {"id": "1-2-3-5", "name": "Jane", "age": 17},
+                            {"id": "1-2-3-6", "name": "Greg", "age": 22},
+                        ],
+                    },
+                ]
+            },
+        )
+        wsgi()
+        ```
+        """
+        return model
 
     ##############################################################
     ### From here down is functionality related to list/search ###