clear-skies 1.18.31__py3-none-any.whl → 1.19.19__py3-none-any.whl

{clear_skies-1.18.31.dist-info → clear_skies-1.19.19.dist-info}/METADATA

@@ -1,22 +1,28 @@
 Metadata-Version: 2.1
 Name: clear-skies
-Version: 1.18.31
+Version: 1.19.19
 Summary: A framework for building backends in the cloud
 Home-page: https://github.com/cmancone/clearskies
 License: MIT
 Author: Conor Mancone
 Author-email: cmancone@gmail.com
-Requires-Python: >=3.8,<4.0
+Requires-Python: >=3.10,<4.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Provides-Extra: jwt
+Provides-Extra: mysql
+Provides-Extra: secrets
+Requires-Dist: akeyless (>=3.6.2,<4.0.0) ; extra == "secrets"
+Requires-Dist: akeyless-cloud-id (>=0.2.3,<0.3.0) ; extra == "secrets"
 Requires-Dist: dateparser (>=1.1.8,<2.0.0)
+Requires-Dist: jose (>=1.0.0,<2.0.0) ; extra == "jwt"
+Requires-Dist: pymysql (>=1.1.0,<2.0.0) ; extra == "mysql"
+Requires-Dist: requests (>=2.31.0,<3.0.0)
 Project-URL: Repository, https://github.com/cmancone/clearskies
 Description-Content-Type: text/markdown
 

{clear_skies-1.18.31.dist-info → clear_skies-1.19.19.dist-info}/RECORD

@@ -46,7 +46,7 @@ clearskies/autodoc/schema/string.py,sha256=oxZPCxYYhWnNHdbtwD3QuniStbj8XbBBpDTFX
 clearskies/backends/__init__.py,sha256=3pvJw5dUnrqt7vyeBFjkHbycUEGkEpoYKxZoJwUVZO0,711
 clearskies/backends/api_backend.py,sha256=vcGYub4G3jLLstTDkMMnZkID9JQz-qHmKNapgde4gSc,8875
 clearskies/backends/backend.py,sha256=fkL-De0MUdzcS2JG_spSUQZIVL9oRFvaL6SP26JPpcI,7399
-clearskies/backends/cursor_backend.py,sha256=B1qpFFr4w459JHgTBMZ16IatMH7urfSBiayZLMj02pk,10804
+clearskies/backends/cursor_backend.py,sha256=VntlPS6z6bnZOC3XRJ-WFf5gK3pFUhH_qJpnZn8hl9U,11278
 clearskies/backends/example_backend.py,sha256=jVpv0LZpNUEJGko0XqioLkHmZHbCW6M4YyNvzKlZcDw,1413
 clearskies/backends/file_backend.py,sha256=tByQdOX1pf6r9-6vRDqOnQ8teRYo0bEWk589qrg598w,1752
 clearskies/backends/json_backend.py,sha256=uDBqkekQadBm0BMoCVuzSPRB-5SjMTCDSAbuIqqwkF8,180
@@ -54,20 +54,22 @@ clearskies/backends/memory_backend.py,sha256=6Ts_NtP9S_QisvpNcQKO0CUqhCRAuL3d5LZ
 clearskies/backends/restful_api_advanced_search_backend.py,sha256=uiR4SEKhLNmczYJEAkVMIdPWxQc4YWSp-_WzcSL7DEo,5480
 clearskies/backends/secrets_backend.py,sha256=4lzrgdL_O_pgCT5HknV2gotFgp9GzjQ5_2n0-4H4kvs,2204
 clearskies/binding_config.py,sha256=bF8LBNEgJacwKCqToAtDqN9hv5omzU7zt_4qB9KPtE0,457
-clearskies/column_types/__init__.py,sha256=WAEB52v0m_Yzg_H3sSGMsRoKFcKkB1oEZXIONocYwy8,3747
-clearskies/column_types/audit.py,sha256=meDFV0s4u9i6UojN5f6EQk_kh-nGP8xPscCRa2Nd-yw,8102
-clearskies/column_types/belongs_to.py,sha256=a64yQ1kWRiljOfHToGsyKbAqdgNLvbRKBYEzrp1IWXo,10714
+clearskies/column_types/__init__.py,sha256=QHEFFd3wRXvaOR7uZk-bpVLlLoTiN3D4S8sBU9rFwCE,4330
+clearskies/column_types/audit.py,sha256=smgAnDzNS5n3_1ESeyqn6KDv_1k6gOYRqrFb8S2_TrQ,9143
+clearskies/column_types/belongs_to.py,sha256=tH1tbTOfjifSNuVjO-KbMF7GiUIoLfcDItrrS3TGGM8,11044
 clearskies/column_types/boolean.py,sha256=1yyM1CUfgD84pPE65c1OP1Qjf_J0Z45hjPrDR51AUkQ,1878
 clearskies/column_types/category_tree.py,sha256=PgNmzZPyqYS5NADH_QTCxLvDXZFxzv5ESKTkvPrrLXo,9140
-clearskies/column_types/column.py,sha256=PUrFyA2KmSyAZTAiJPfHy5Dlc1YPEb62c7r0BOTkF1s,13541
-clearskies/column_types/created.py,sha256=R8P3egUb7JEHoU_NtbmN9OIwBUHQ0XFi1GoAb5RpSkI,339
+clearskies/column_types/column.py,sha256=ftuDFswjk-KE9Frxo1rhgkjr4sjSjnUc5ZtfNrnGLIc,15530
+clearskies/column_types/created.py,sha256=S78e1VuvvUPYiI79gWGqlPzMSLIbXMpaYQMw8as7l38,615
 clearskies/column_types/created_by_authorization_data.py,sha256=--1w1TOSo2CMwrpn6Y_iorl2RTqLgG8MbR8k27qreew,1108
 clearskies/column_types/created_by_header.py,sha256=5sY6vjtra-BrAgUE4zkuLhBtzCVWHNtJPwMozPw_7_s,520
 clearskies/column_types/created_by_ip.py,sha256=wwCUoEwHEVGN89x4xP7NJ6QR85Aum6v3JmxofoQrqtg,395
 clearskies/column_types/created_by_routing_data.py,sha256=EhVorRaGV2OhEb0YSPwPmrsK2NQycYgGEd4ab8-qI2I,569
 clearskies/column_types/created_by_user_agent.py,sha256=sSYDRrqSjsCwcYlhF_s9NO-iDww3PaH6aO2ATp_SKGQ,419
-clearskies/column_types/datetime.py,sha256=MuVaeI6FMgevTdgv6djZjlHogs72TC1HTuYdw_6MF2M,3824
-clearskies/column_types/email.py,sha256=rCaCFCxGhVzJcYVeGm98S6e7myJ6eQX9YznqAZIgwQI,606
+clearskies/column_types/created_micro.py,sha256=EqeHB3ZHbi4nCa1rbrKy1TbooT9U3Kfw5z4jUvLi32U,636
+clearskies/column_types/datetime.py,sha256=OEy5eMfqWp6KOqEHQa3Ga_tl0oawtcMRBafI1SPYDFk,4275
+clearskies/column_types/datetime_micro.py,sha256=3DxtkeJZhWigdni7QEJFV3BJuCmXJMyFQjDZ9jyI144,328
+clearskies/column_types/email.py,sha256=qq0Yo_C3KxUqT68q2HWXocBBR4xwMqjxcIdgZRv218U,584
 clearskies/column_types/float.py,sha256=j8jJeBueSOusPtAFCWgLHYBncfLnqT1U7bh1zcAkYiA,1332
 clearskies/column_types/has_many.py,sha256=Z4oM1g2dQx6H9171c52FLC41nLryCOKmh51I75mYmmY,5895
 clearskies/column_types/integer.py,sha256=dGIluusPmhLRNg7PplOJLbQI2AXojqRBUHt8ekYWNVI,1386
@@ -76,7 +78,8 @@ clearskies/column_types/many_to_many.py,sha256=Yu5wmMkVqRteMrH_8uSZK-bM_IrfDyv6A
 clearskies/column_types/many_to_many_with_data.py,sha256=NOYjZedeLIWVyDV4BTRyNmhkNHZzx6SkHLFbL-VqHQU,7769
 clearskies/column_types/select.py,sha256=1oBslTJ_7QCjlFeEcwJVRL-ED4sXwCESVFRAOonvG2I,297
 clearskies/column_types/string.py,sha256=XbHC31TmlW0k86cvdVJBDyowU8Xis6Te6R0rPLXgLpI,863
-clearskies/column_types/updated.py,sha256=ZAHTHZtKbZQE_JwZ2wMwAUSr4PUYNscy8SwzZGko8hU,290
+clearskies/column_types/updated.py,sha256=FNyRK-PS6lgFQ9QN2VrcIZP2g5EHGhll6pf-MgqMH7s,566
+clearskies/column_types/updated_micro.py,sha256=3geqsV4nsPB9xDKyvQDGniU-KMqM8WvoqHfUYcBqGJY,587
 clearskies/column_types/uuid.py,sha256=pA6Cd-1QSRuUpz0PxWAGRdG01hW7bpIicOhhJvAvDkQ,711
 clearskies/columns.py,sha256=3PgLopL1l20vVWaUqOJkwXMr06a-gFHEsbExfOWVB4I,5925
 clearskies/condition_parser.py,sha256=IXl51-rDxws7-nAtTVu_m6gTegtpkDnoGAFX2MTPDIo,6589
@@ -87,7 +90,7 @@ clearskies/contexts/cli.py,sha256=25GpL2PcuUiqesZx8_chBhyk3dqr4qpitp6xe6N4G7U,11
 clearskies/contexts/context.py,sha256=0ufURXBDPaoYVuhU-IB8VmHABQlgiQYo5TgUZeXv5to,2589
 clearskies/contexts/convert_to_application.py,sha256=5Y3eocNomUQYVX9kcLdf9vc-hItw1R1ns59bz5P3dbU,9602
 clearskies/contexts/extract_handler.py,sha256=lmWACrV5KbE9vPHPYyg1vz1bWcLwt8WHtgHHL-lXB_k,1896
-clearskies/contexts/test.py,sha256=LLLTJzGY606ve2jjjf3qrKSxKqaPjSbdqcRFNLvMChc,3054
+clearskies/contexts/test.py,sha256=BEK8ltTGH4sB8oLcBzv-uqzaTEzXzGVVU7qrLGUicwg,3194
 clearskies/contexts/wsgi.py,sha256=6b69s3aHj3ZlL47LEulV-UveZprVXApZgFiN9qkqTxU,834
 clearskies/decorators/__init__.py,sha256=bv515ELZ83cG2MUtOmp7nT9pQxrrBVEkLPKUDYppBbY,936
 clearskies/decorators/auth0_jwks.py,sha256=tIVAJhIfW9h_2yv4BAqW2eVMb1AK4AlKylzBc2aKDBc,681
@@ -119,9 +122,9 @@ clearskies/di/test_module/another_module/__init__.py,sha256=8SRmHPDepLKGWTUSc1uc
 clearskies/di/test_module/module_class.py,sha256=I_-wnMuHfbsvti-7d2Z4bXnr6deo__uvww9nds9qrlE,46
 clearskies/environment.py,sha256=n2IMpNMakHJ7KJJ7sEQlxd4jfzAzqejxcTKxElyo1Us,3591
 clearskies/functional/__init__.py,sha256=em6xhpGOws_egf6jWfeQlxq0Vm5gYzsbMNt_rxTZzqk,95
-clearskies/functional/string.py,sha256=Jmz8G9PW41THIRfDT2WXtRk3yzJG3Zt4DKH6X2C2p1E,2829
+clearskies/functional/string.py,sha256=HHXou_lyjntX7SMi0-hfe91Kk3grxQnU-7oi4Lon35Q,3015
 clearskies/functional/validations.py,sha256=f1fTQ4rdFZouxoovAPg-YAgf0Q0QNpKEzxWWL7EFUHI,645
-clearskies/handlers/__init__.py,sha256=YIQeKkkFhXwn7Rcc7Qllh2RGkKB0nDjt1nwowqEuJ3E,968
+clearskies/handlers/__init__.py,sha256=9tH0zk4g7Mt22opD1NlynqXwwMX2DHzLmAVihZsJsfU,1011
 clearskies/handlers/advanced_search.py,sha256=UbWDntGAGD5NM61yKEws5MfG0Xy3K_fn-i-X9FG-mKs,13746
 clearskies/handlers/base.py,sha256=veR6tLPS0T9dOB9cilb6b3ausgsu5bcqEqLkMuNjJvg,22428
 clearskies/handlers/callable.py,sha256=2pVMwllttNui4R5vlLpufPehAPL_ksh-5eBrUprNv8U,8113
@@ -135,32 +138,39 @@ clearskies/handlers/exceptions/authorization.py,sha256=14JuU5zLEf2sv82VNxsJt7dGS
 clearskies/handlers/exceptions/client_error.py,sha256=o1OGnjlXT5zZ1Vb2LTRPYIio0YAnXPpXDGuqSLQP9_Y,39
 clearskies/handlers/exceptions/input_error.py,sha256=kmEVv9LNIalLKD9GF-olsD39Z94abHGkB54NskOG6g4,136
 clearskies/handlers/exceptions/not_found.py,sha256=xThOXiMfyYBaI2bhfOhpVoZ_vdw1hU8A_HxHenPqHzo,96
-clearskies/handlers/get.py,sha256=GHXlhXiuewu9E54RsCo7BPyFXQ7m5tCyiAPHIgb8Qok,6820
+clearskies/handlers/get.py,sha256=x9SogDd2ZvIYwv2UkNa_FUmmKMNd9XPadkbnBKbyTGo,6892
 clearskies/handlers/health_check.py,sha256=m6H3psUql-I7hZao3fsxjrZnCjFJZ1ROTF-41g8Syww,2078
 clearskies/handlers/input_processing.py,sha256=edtG6NQJZCte0Nq-j7SUMzp6vxgIIbLxeUGscWOALAs,3814
-clearskies/handlers/list.py,sha256=Liil791oF9-NjofRV40bNVbhbzF4sM74_efvoDHenqg,25384
+clearskies/handlers/list.py,sha256=RdhvcVA4ZgkdmOHl6iGBC-2jPhjYay0_kFHttmVoq9Q,25466
 clearskies/handlers/mygrations.py,sha256=4iKpJKooqgNtAURwMl_FgsXUt8OYOaG_TY1OV1llQxY,2759
 clearskies/handlers/request_method_routing.py,sha256=DgPEz3tgbaUkXHsOriPbIctfSf4Gm4NxfRdVulH91Kg,1636
 clearskies/handlers/restful_api.py,sha256=1rJ2REX1sTAdbqaRuCclP375agrho4zNNQx6hXGa4nQ,9258
 clearskies/handlers/routing.py,sha256=uWKWcEaiHVqfDebPkQVuG9AS8pOixW31wW0yIQ-25Aw,3079
 clearskies/handlers/schema_helper.py,sha256=62644USvFlZu_6tT7rb-k6t_5J3Q0uZsJwP5KREk_WM,4961
 clearskies/handlers/simple_routing.py,sha256=KpOSQK2_tTwrPblDmxAUpX-Fqts_Or_MLWGKOOkJnoo,9403
-clearskies/handlers/simple_routing_route.py,sha256=kDoplYQW54WvROgHOAq5yLqloIMHnIIWZHCnkmzT_G0,8924
+clearskies/handlers/simple_routing_route.py,sha256=3U3dixEKuf-Xo88RQGH_grm1x79-px6idt1-xaLUSiY,8953
 clearskies/handlers/simple_search.py,sha256=bSfq8rzdqkBj-dTGUBSZ1EkfjzUWHID7mKD2xEf8VzQ,6165
-clearskies/handlers/update.py,sha256=VCZkoID7i5VHq78fkIpjbRdXQ4Z3IuXEE5dfC8z4RZI,4088
-clearskies/handlers/write.py,sha256=VduGtjnFMQOvo3l0t-tUP4PExPJ9JEpuziHsquF08rE,9344
+clearskies/handlers/update.py,sha256=rx8HW87Pfh95e_9nEfKKnxfkh2HBlCUdYqVwljtXiJ8,4116
+clearskies/handlers/write.py,sha256=Gu1w1PQ1F7tlqCqALorMRek3UH6IkViPIO195dxPd8k,9372
 clearskies/input_outputs/__init__.py,sha256=mQWL-u41FRTrPGuHe8FhLmcHjAEaUxjFwUf7RgDcbAs,182
-clearskies/input_outputs/cli.py,sha256=snIfLFakIqDXm-AXVN6qes0tZsg2IM7T1riFzDdHlMM,6254
+clearskies/input_outputs/cli.py,sha256=F54wues9cNESE8FhQP3mDWrgrZyFouDIN-ZZ3-KJjks,6258
 clearskies/input_outputs/exceptions/__init__.py,sha256=bc5Tc1XBZnqA1fKbk7pk5hyx102vqx3sDE19E03xGk4,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
 clearskies/input_outputs/input_output.py,sha256=vYKn9SE5erS4LuOhhAsXqaOEsGXwZ1NJ4v85KN1Xg6A,4501
-clearskies/input_outputs/wsgi.py,sha256=bqRzzJLifAVXgXw1Lsg0lQ0uwZ8SLSn-NSbD5dKrSw4,3138
-clearskies/input_requirements/__init__.py,sha256=MpR-oEn1aLHdWHI60Y0QN2q6FyqqySCxcEaHR51aKpk,602
+clearskies/input_outputs/wsgi.py,sha256=9p82eJP5FUAI6jbIojvydG3_9gncX7vcUACQMyRN9x4,3142
+clearskies/input_requirements/__init__.py,sha256=vIqm8KDiomQSxT7WjogFi1yOOrsVrNMb5GKlfw5USNk,1836
+clearskies/input_requirements/after.py,sha256=TXy8bIVz_77a8oJuohPwoM5E--AOVWsOSjjh5PpA2Ys,1544
+clearskies/input_requirements/before.py,sha256=iLg-Hub9iW2eP19s5fkPrA9TCT_-DTm5KoxgA8ho0-k,1547
+clearskies/input_requirements/in_the_future_at_least.py,sha256=PLVp_2Yv-1ScKnajlc9hjG7qYZhadKXHNTkRP7WKUdo,739
+clearskies/input_requirements/in_the_future_at_most.py,sha256=L5Oz47KAHv5WL6Nu2vGkql6q8Ha9IKJMj-uxQkyuIdc,737
+clearskies/input_requirements/in_the_past_at_least.py,sha256=ES0SgtADHcu7HZDdvIFyD9vpYTnrd4hBi03OShqUZg4,735
+clearskies/input_requirements/in_the_past_at_most.py,sha256=hvhn_K1X4f7pbpFhjavR6Mu48JhhYcEIUx44YWfa_7E,733
 clearskies/input_requirements/maximum_length.py,sha256=7hdGVq914BtZQwiGOLOU-t5QTDNQtCPT4TOnYTUo3Wo,689
 clearskies/input_requirements/minimum_length.py,sha256=qSpLjNBu6AKRoBZi3jvCMYKsHwsknbkUk86C8CMIOEU,987
 clearskies/input_requirements/required.py,sha256=luYP527YPkQIVNVPhnNztOI0UxO67gNqn3FiLBId1YE,1133
 clearskies/input_requirements/requirement.py,sha256=5wUywAvbEQPh9tpfwWX3gdi4dwI-Xs9ePyC30qvwPaQ,584
+clearskies/input_requirements/time_delta.py,sha256=lqajxGEp2zZB_Rk-dG8eWgpljbuph1yqZMuylYRYJKs,1247
 clearskies/input_requirements/unique.py,sha256=gpbm9uoXcy8WCHsuWqAotwockbjDfJOWitIbK_3ngN0,777
 clearskies/mocks/__init__.py,sha256=T68OUB9gGCX0WoisGzsY3Bt2cCFX7ILHKPqi6XKTJM0,113
 clearskies/mocks/input_output.py,sha256=2wD5GbUyVSkXcBg1GTZ-Oz9VzcYxNHfTlmZAODW-7CI,3898
@@ -189,7 +199,7 @@ clearskies/tests/simple_api/models/__init__.py,sha256=nUA0W6fgXw_Bxa9CudkaDkC80t
 clearskies/tests/simple_api/models/status.py,sha256=PEhPbaQh5qdUNHp8O0gz91LOLENAEBtqSaHxUPXchaM,699
 clearskies/tests/simple_api/models/user.py,sha256=5_P4Tp1tTdX7PkMJ__epPM5MA7JAeVYGas69vcWloLc,819
 clearskies/tests/simple_api/users_api.py,sha256=KYXCgEofDxHeRdQK67txN5oYUPvxxmB8JTku7L-apk4,2344
-clear_skies-1.18.31.dist-info/LICENSE,sha256=3Ehd0g3YOpCj8sqj0Xjq5qbOtjjgk9qzhhD9YjRQgOA,1053
-clear_skies-1.18.31.dist-info/METADATA,sha256=oPp3u-OCfE-hLSzV_BWIXSTnoErSgPLmhcg2TLrArBE,1367
-clear_skies-1.18.31.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
-clear_skies-1.18.31.dist-info/RECORD,,
+clear_skies-1.19.19.dist-info/LICENSE,sha256=3Ehd0g3YOpCj8sqj0Xjq5qbOtjjgk9qzhhD9YjRQgOA,1053
+clear_skies-1.19.19.dist-info/METADATA,sha256=tHoiNbV-s9t99A7Ta16RB7VYyaFfEKG95uXBWGc1LNE,1622
+clear_skies-1.19.19.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
+clear_skies-1.19.19.dist-info/RECORD,,

clearskies/backends/cursor_backend.py

@@ -138,9 +138,22 @@ class CursorBackend(Backend):
                 next_page_data["start"] = int(start) + int(limit)
         return records
 
+    def group_by_clause(self, group_by):
+        if not group_by:
+            return ""
+        escape = self._column_escape_character()
+        if "." not in group_by:
+            return f" GROUP BY {escape}{group_by}{escape}"
+        parts = group_by.split(".", 1)
+        table = parts[0]
+        column = parts[1]
+        return f" GROUP BY {escape}{table}{escape}.{escape}{column}{escape}"
+
     def as_sql(self, configuration):
         escape = self._column_escape_character()
-        [wheres, parameters] = self._conditions_as_wheres_and_parameters(configuration["wheres"])
+        [wheres, parameters] = self._conditions_as_wheres_and_parameters(
+            configuration["wheres"], configuration["table_name"]
+        )
         select_parts = []
         if configuration["select_all"]:
             select_parts.append(self._finalize_table_name(configuration["table_name"]) + ".*")
@@ -162,11 +175,7 @@ class CursorBackend(Backend):
             order_by = " ORDER BY " + ", ".join(sort_parts)
         else:
             order_by = ""
-        group_by = (
-            f" GROUP BY {escape}" + configuration["group_by_column"] + escape
-            if configuration["group_by_column"]
-            else ""
-        )
+        group_by = self.group_by_clause(configuration["group_by_column"])
         limit = ""
         if configuration["limit"]:
             start = 0
@@ -183,7 +192,9 @@ class CursorBackend(Backend):
     def as_count_sql(self, configuration):
         escape = self._column_escape_character()
         # note that this won't work if we start including a HAVING clause
-        [wheres, parameters] = self._conditions_as_wheres_and_parameters(configuration["wheres"])
+        [wheres, parameters] = self._conditions_as_wheres_and_parameters(
+            configuration["wheres"], configuration["table_name"]
+        )
         # we also don't currently support parameters in the join clause - I'll probably need that though
         if configuration["joins"]:
             # We can ignore left joins because they don't change the count
@@ -195,10 +206,13 @@ class CursorBackend(Backend):
         if not configuration["group_by_column"]:
             query = f"SELECT COUNT(*) AS count FROM {table_name}{joins}{wheres}"
         else:
-            query = f'SELECT COUNT(SELECT 1 FROM {table_name}{joins}{wheres} GROUP BY {escape}{configuration["group_by_column"]}{escape}) AS count'
+            group_by = self.group_by_clause(configuration["group_by_column"])
+            query = (
+                f"SELECT COUNT(*) AS count FROM (SELECT 1 FROM {table_name}{joins}{wheres}{group_by}) AS count_inner"
+            )
         return [query, parameters]
 
-    def _conditions_as_wheres_and_parameters(self, conditions):
+    def _conditions_as_wheres_and_parameters(self, conditions, default_table_name):
         if not conditions:
             return ["", []]
 
@@ -206,16 +220,17 @@ class CursorBackend(Backend):
         where_parts = []
         for condition in conditions:
             parameters.extend(condition["values"])
-            table = condition.get("table", "")
+            table = condition.get("table", default_table_name)
+            if not table:
+                table = default_table_name
             column = condition["column"]
-            column_with_table = f"{table}.{column}" if table else column
+            column_with_table = f"{table}.{column}"
             where_parts.append(
                 self.condition_parser._with_placeholders(
                     column_with_table,
                     condition["operator"],
                     condition["values"],
-                    escape=False if table else True,
-                    escape_character=self._column_escape_character(),
+                    escape=False,
                 )
             )
         return [" WHERE " + " AND ".join(where_parts), parameters]

clearskies/column_types/__init__.py

@@ -9,7 +9,9 @@ from .created_by_header import CreatedByHeader
 from .created_by_ip import CreatedByIp
 from .created_by_routing_data import CreatedByRoutingData
 from .created_by_user_agent import CreatedByUserAgent
+from .created_micro import CreatedMicro
 from .datetime import DateTime
+from .datetime_micro import DateTimeMicro
 from .email import Email
 from .float import Float
 from .has_many import HasMany
@@ -20,6 +22,7 @@ from .many_to_many_with_data import ManyToManyWithData
 from .select import Select
 from .string import String
 from .updated import Updated
+from .updated_micro import UpdatedMicro
 from .uuid import UUID
 
 
@@ -67,10 +70,18 @@ def created_by_user_agent(name, **kwargs):
     return build_column_config(name, CreatedByUserAgent, **kwargs)
 
 
+def created_micro(name, **kwargs):
+    return build_column_config(name, CreatedMicro, **kwargs)
+
+
 def datetime(name, **kwargs):
     return build_column_config(name, DateTime, **kwargs)
 
 
+def datetime_micro(name, **kwargs):
+    return build_column_config(name, DateTimeMicro, **kwargs)
+
+
 def email(name, **kwargs):
     return build_column_config(name, Email, **kwargs)
 
@@ -111,6 +122,10 @@ def updated(name, **kwargs):
     return build_column_config(name, Updated, **kwargs)
 
 
+def updated_micro(name, **kwargs):
+    return build_column_config(name, UpdatedMicro, **kwargs)
+
+
 def uuid(name, **kwargs):
     return build_column_config(name, UUID, **kwargs)
 
@@ -127,15 +142,21 @@ __all__ = [
     "CategoryTree",
     "Column",
     "created",
+    "created_micro",
     "Created",
+    "CreatdMicro",
     "created_by_authorization_data",
     "CreatedByAuthorizationData",
     "created_by_ip",
     "CreatedByIp",
     "created_by_user_agent",
     "CreatedByUserAgent",
+    "CreatedMicro",
+    "created_micro",
     "datetime",
+    "datetime_micro",
     "DateTime",
+    "DateTimeMicro",
     "email",
     "Email",
     "float",
@@ -155,7 +176,9 @@ __all__ = [
     "string",
     "String",
     "updated",
+    "updated_micro",
     "Updated",
+    "UpdatedMicro",
     "uuid",
     "UUID",
 ]

clearskies/column_types/audit.py

@@ -29,6 +29,9 @@ class Audit(has_many.HasMany):
     With `exclude_columns` you can specify some names of columns to ignore.  If an update happens and only columns
     in `exclude_columns` are being set, then a history entry will not be created.  Also, these columns will
     not be included in the audit record.
+
+    With `mask_columns` you can specify the names of columns which should be noted as updated in the audit record,
+    but the actual values (before and after) should not be recorded.
     """
 
     _parent_columns = None
@@ -40,6 +43,7 @@ class Audit(has_many.HasMany):
     my_configs = [
         "child_models_class",
         "exclude_columns",
+        "mask_columns",
         "foreign_column_name",
         "is_readable",
         "readable_child_columns",
@@ -65,6 +69,7 @@ class Audit(has_many.HasMany):
             "readable_child_columns": ["resource_id", "action", "data", "created_at"],
             "parent_class_name": model_class.__name__,
             "exclude_columns": configuration.get("exclude_columns", []),
+            "mask_columns": configuration.get("mask_columns", []),
         }
         super().configure(name, has_many_configuration, model_class)
 
@@ -92,21 +97,21 @@ class Audit(has_many.HasMany):
                     + " but it has something else"
                 )
 
-        if "exclude_columns" in configuration:
-            exclude_columns = configuration["exclude_columns"]
-            if not hasattr(exclude_columns, "__iter__"):
-                raise ValueError(
-                    f"{error_prefix} 'exclude_columns' should be an iterable " + "with the list of columns to exclude."
-                )
-            if isinstance(exclude_columns, str):
+        for config_name in ["exclude_columns", "mask_columns"]:
+            if config_name not in configuration:
+                continue
+
+            config_columns = configuration[config_name]
+            if not hasattr(config_columns, "__iter__"):
+                raise ValueError(f"{error_prefix} '{config_name}' should be an iterable with the list of column names.")
+            if isinstance(config_columns, str):
                 raise ValueError(
-                    f"{error_prefix} 'exclude_columns' should be an iterable "
-                    + "with the list of child columns to output."
+                    f"{error_prefix} '{config_name}' should be an iterable " + "with a list of column names."
                 )
-            for column_name in exclude_columns:
+            for column_name in config_columns:
                 if column_name not in parent_columns:
                     raise ValueError(
-                        f"{error_prefix} 'exclude_columns' references column named '{column_name}' but this"
+                        f"{error_prefix} '{config_name}' references column named '{column_name}' but this"
                         + " column does not exist in the original model class."
                     )
 
@@ -118,6 +123,7 @@ class Audit(has_many.HasMany):
         old_data = model._previous_data
         new_data = model._data
         exclude_columns = self.config("exclude_columns")
+        mask_columns = self.config("mask_columns")
         parent_columns = self.parent_columns
 
         if not old_data:
@@ -129,6 +135,8 @@ class Audit(has_many.HasMany):
                     **create_data,
                     **parent_columns[key].to_json(model),
                 }
+                if key in mask_columns and key in create_data:
+                    create_data[key] = "****"
             self.record(model, "create", data=create_data)
             return
 
@@ -152,6 +160,9 @@ class Audit(has_many.HasMany):
                 **to_data,
                 **parent_columns[column].to_json(model),
             }
+            if column in mask_columns and column in to_data:
+                to_data[column] = "****"
+                from_data[column] = "****"
         if not from_data and not to_data:
             return
 
@@ -168,15 +179,28 @@ class Audit(has_many.HasMany):
         super().post_delete(model)
         exclude_columns = self.config("exclude_columns")
         parent_columns = self.parent_columns
+        mask_columns = self.config("mask_columns")
+
+        final_data = {}
+        for key in model._data.keys():
+            if key in exclude_columns:
+                continue
+            final_data = {
+                **final_data,
+                **parent_columns[key].to_json(model),
+            }
+
+        for key in mask_columns:
+            if key not in final_data:
+                continue
+            final_data[key] = "****"
 
         self.child_models.create(
             {
                 "class": self.config("parent_class_name"),
                 "resource_id": model.get(self.config("parent_id_column_name")),
                 "action": "delete",
-                "data": {
-                    key: parent_columns[key].to_json(model) for key in model._data.keys() if key not in exclude_columns
-                },
+                "data": final_data,
             }
         )
 
@@ -186,7 +210,7 @@ class Audit(has_many.HasMany):
             self._parent_columns = self.di.build(self.model_class, cache=True).columns()
         return self._parent_columns
 
-    def record(self, model, action, data=None):
+    def record(self, model, action, data=None, record_data=None):
         audit_data = {
             "class": self.config("parent_class_name"),
             "resource_id": model.get(self.config("parent_id_column_name")),
@@ -194,6 +218,12 @@ class Audit(has_many.HasMany):
         }
         if data is not None:
             audit_data["data"] = data
+        if record_data is not None:
+            audit_data = {
+                **audit_data,
+                **record_data,
+            }
+
         self.child_models.create(audit_data)
 
 

clearskies/column_types/belongs_to.py

@@ -98,7 +98,15 @@ class BelongsTo(String):
             return integer_check
         parent_models = self.parent_models
         id_column_name = parent_models.get_id_column_name()
-        if not len(parent_models.where(f"{id_column_name}={value}")):
+        matching_parents = parent_models.where(f"{id_column_name}={value}")
+        input_output = self.di.build("input_output", cache=True)
+        matching_parents = matching_parents.where_for_request(
+            matching_parents,
+            input_output.routing_data(),
+            input_output.get_authorization_data(),
+            input_output,
+        )
+        if not len(matching_parents):
             return f"Invalid selection for {self.name}: record does not exist"
         return ""
 

clearskies/column_types/column.py

@@ -19,6 +19,8 @@ class Column(ABC):
         "on_change",
         "default",
         "setable",
+        "created_by_source_type",
+        "created_by_source_key",
     ]
 
     def __init__(self, di):
@@ -91,12 +93,47 @@ class Column(ABC):
         if configuration.get("on_change"):
             self._check_actions(configuration.get("on_change"), "on_change")
 
+        self._check_created_by_source(configuration)
+
     def _finalize_configuration(self, configuration):
         """Make any changes to the configuration/fill in defaults"""
         if not "input_requirements" in configuration:
             configuration["input_requirements"] = []
         return configuration
 
+    def _check_created_by_source(self, configuration):
+        source_type = configuration.get("created_by_source_type")
+        source_key = configuration.get("created_by_source_key")
+        if not source_type and not source_key:
+            return
+
+        error_prefix = f"Misconfiguration for column '{self.name}' in '{self.model_class.__name__}': "
+        if not source_type or not source_key:
+            raise ValueError(
+                f"{error_prefix} must provide both 'created_by_source_type' and 'created_by_source_key' but only one was provided."
+            )
+
+        if not isinstance(source_type, str):
+            raise ValueError(
+                f"{error_prefix} 'created_by_source_type' must be a string but is a '"
+                + source_type.__class__.__name__
+                + "'"
+            )
+        if not isinstance(source_key, str):
+            raise ValueError(
+                f"{error_prefix} 'created_by_source_key' must be a string but is a '"
+                + source_key.__class__.__name__
+                + "'"
+            )
+
+        allowed_types = ["authorization_data"]
+        if source_type not in allowed_types:
+            raise ValueError(
+                f"{error_prefix} 'created_by_source_type' must be one of '" + "', '".join(allowed_types) + "'"
+            )
+        if configuration.get("setable"):
+            raise ValueError(f"{error_prefix} you cannot set both 'setable' and 'created_by_source_type'")
+
     def _check_actions(self, actions, trigger_name):
         """Check that the given actions are actually understandable by the system"""
         if type(actions) != list:
@@ -189,14 +226,20 @@ class Column(ABC):
         The difference between this and post_save is that this happens before the database is updated.
         As a result, if you need the model id to make your changes, it has to happen in post_save, not pre_save
         """
-        if not model.exists and "default" in self.configuration and self.name not in data:
-            data[self.name] = self.configuration["default"]
+        if not model.exists:
+            source_type = self.configuration.get("created_by_source_type")
+            if source_type:
+                if source_type == "authorization_data":
+                    authorization_data = self.di.build("input_output", cache=True).get_authorization_data()
+                    data[self.name] = authorization_data.get(self.config("created_by_source_key"), "N/A")
         if "setable" in self.configuration:
             setable = self.configuration["setable"]
             if callable(setable):
                 data[self.name] = self.di.call_function(setable, data=data, model=model)
             else:
                 data[self.name] = setable
+        if not model.exists and "default" in self.configuration and self.name not in data:
+            data[self.name] = self.configuration["default"]
         return data
 
     def post_save(self, data, model, id):

clearskies/column_types/created.py

@@ -2,9 +2,15 @@ from .datetime import DateTime
 
 
 class Created(DateTime):
-    def __init__(self, di, now):
+    my_configs = [
+        "date_format",
+        "default_date",
+        "utc",
+    ]
+
+    def __init__(self, di, datetime):
         super().__init__(di)
-        self.now = now
+        self.datetime = datetime
 
     @property
     def is_writeable(self):
@@ -13,4 +19,8 @@ class Created(DateTime):
     def pre_save(self, data, model):
         if model.exists:
             return data
-        return {**data, self.name: self.now}
+        if self.config("utc", silent=True):
+            now = self.datetime.datetime.now(self.datetime.timezone.utc)
+        else:
+            now = self.datetime.datetime.now()
+        return {**data, self.name: now}

clearskies/column_types/created_micro.py

@@ -0,0 +1,26 @@
+from .datetime_micro import DateTimeMicro
+
+
+class CreatedMicro(DateTimeMicro):
+    my_configs = [
+        "date_format",
+        "default_date",
+        "utc",
+    ]
+
+    def __init__(self, di, datetime):
+        super().__init__(di)
+        self.datetime = datetime
+
+    @property
+    def is_writeable(self):
+        return False
+
+    def pre_save(self, data, model):
+        if model.exists:
+            return data
+        if self.config("utc", silent=True):
+            now = self.datetime.datetime.now(self.datetime.timezone.utc)
+        else:
+            now = self.datetime.datetime.now()
+        return {**data, self.name: now}

clearskies/column_types/datetime.py

@@ -6,12 +6,28 @@ from ..autodoc.schema import DateTime as AutoDocDateTime
 
 class DateTime(Column):
     _auto_doc_class = AutoDocDateTime
+    _date_format = "%Y-%m-%d %H:%M:%S"
+    _default_date = "0000-00-00 00:00:00"
+
+    my_configs = [
+        "date_format",
+        "default_date",
+    ]
 
     def __init__(self, di):
         super().__init__(di)
 
+    def _finalize_configuration(self, configuration):
+        return {
+            **{
+                "date_format": self._date_format,
+                "default_date": self._default_date,
+            },
+            **super()._finalize_configuration(configuration),
+        }
+
     def from_backend(self, value):
-        if not value or value == "0000-00-00 00:00:00":
+        if not value or value == self.config("default_date"):
             date = None
         elif type(value) == str:
             date = dateparser.parse(value)
@@ -24,14 +40,14 @@ class DateTime(Column):
             return data
 
         # hopefully this is a Python datetime object in UTC timezone...
-        return {**data, **{self.name: data[self.name].strftime("%Y-%m-%d %H:%M:%S")}}
+        return {**data, **{self.name: data[self.name].strftime(self.config("date_format"))}}
 
     def to_json(self, model):
         datetime = model.get(self.name, silent=True)
         return {self.name: datetime.isoformat() if datetime else None}
 
     def build_condition(self, value, operator=None, column_prefix=""):
-        date = dateparser.parse(value).astimezone(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+        date = dateparser.parse(value).astimezone(timezone.utc).strftime(self.config("date_format"))
         if not operator:
             operator = "="
         return f"{column_prefix}{self.name}{operator}{date}"

clearskies/column_types/datetime_micro.py

@@ -0,0 +1,12 @@
+from .datetime import DateTime
+from datetime import datetime, timezone
+import dateparser
+from ..autodoc.schema import DateTime as AutoDocDateTime
+
+
+class DateTimeMicro(DateTime):
+    _date_format = "%Y-%m-%d %H:%M:%S.%f"
+    _default_date = "0000-00-00 00:00:00.000000"
+
+    def __init__(self, di):
+        super().__init__(di)

clearskies/column_types/email.py

@@ -13,6 +13,6 @@ class Email(String):
             # don't check for an email if doing a fuzzy search, since we may be searching
             # for a partial email
             return ""
-        if re.search("^[a-z0-9]+[\\._]?[a-z0-9]+[@]\\w+[.]\\w{2,3}$", value):
+        if re.search(r"^[^@\s]+@[^@]+\.[^@]+$", value):
             return ""
         return "Invalid email address"

clearskies/column_types/updated.py

@@ -2,13 +2,23 @@ from .datetime import DateTime
 
 
 class Updated(DateTime):
-    def __init__(self, di, now):
+    my_configs = [
+        "date_format",
+        "default_date",
+        "utc",
+    ]
+
+    def __init__(self, di, datetime):
         super().__init__(di)
-        self.now = now
+        self.datetime = datetime
 
     @property
     def is_writeable(self):
         return False
 
     def pre_save(self, data, model):
-        return {**data, self.name: self.now}
+        if self.config("utc", silent=True):
+            now = self.datetime.datetime.now(self.datetime.timezone.utc)
+        else:
+            now = self.datetime.datetime.now()
+        return {**data, self.name: now}

clearskies/column_types/updated_micro.py

@@ -0,0 +1,24 @@
+from .datetime_micro import DateTimeMicro
+
+
+class UpdatedMicro(DateTimeMicro):
+    my_configs = [
+        "date_format",
+        "default_date",
+        "utc",
+    ]
+
+    def __init__(self, di, datetime):
+        super().__init__(di)
+        self.datetime = datetime
+
+    @property
+    def is_writeable(self):
+        return False
+
+    def pre_save(self, data, model):
+        if self.config("utc", silent=True):
+            now = self.datetime.datetime.now(self.datetime.timezone.utc)
+        else:
+            now = self.datetime.datetime.now()
+        return {**data, self.name: now}

clearskies/contexts/test.py

@@ -39,6 +39,7 @@ class Test(Context):
         input_output=None,
         query_parameters=None,
         authorization_data=None,
+        context_specifics=None,
     ):
         if self.application is None:
             raise ValueError("Cannot call the test context without an application")
@@ -59,6 +60,8 @@ class Test(Context):
             input_output.set_query_parameters(query_parameters)
         if authorization_data is not None:
             input_output.set_authorization_data(authorization_data)
+        if context_specifics is not None:
+            input_output.set_context_specifics(context_specifics)
 
         self.handler = self.di.build(self.application.handler_class, cache=False)
         self.handler.configure(

clearskies/functional/string.py

@@ -1,4 +1,5 @@
 import re
+import datetime
 
 
 def camel_case_to_snake_case(string: str) -> str:
@@ -95,3 +96,9 @@ def make_plural(singular: str):
     if singular[-1] == "s":
         return singular + "es"
     return f"{singular}s"
+
+
+def datetime_to_iso(value):
+    if not isinstance(value, datetime.date) and not isinstance(value, datetime.datetime):
+        return value
+    return value.isoformat()

clearskies/handlers/__init__.py

@@ -16,8 +16,10 @@ from .write import Write
 from .schema_helper import SchemaHelper
 from .simple_routing import SimpleRouting
 from .simple_search import SimpleSearch
+from . import exceptions
 
 __all__ = [
+    "exceptions",
     "AdvancedSearch",
     "Callable",
     "Create",

clearskies/handlers/get.py

@@ -25,14 +25,16 @@ class Get(Base):
             return self.error(input_output, model, 404)
         return self.success(input_output, self._model_as_json(model, input_output))
 
-    def fetch_model(self, input_output):
+    def get_model_id(self, input_output):
         routing_data = input_output.routing_data()
         if self.id_column_name in routing_data:
-            id = routing_data[self.id_column_name]
-        elif "id" in routing_data:
-            id = routing_data["id"]
-        else:
-            raise ValueError("I didn't receive the ID in my routing data.  I am probably misconfigured.")
+            return routing_data[self.id_column_name]
+        if "id" in routing_data:
+            return routing_data["id"]
+        raise ValueError("I didn't receive the ID in my routing data.  I am probably misconfigured.")
+
+    def fetch_model(self, input_output):
+        id = self.get_model_id(input_output)
         models = self._model.where(f"{self.id_column_name}={id}")
         for where in self.configuration("where"):
             if type(where) == str:

clearskies/handlers/list.py

@@ -255,11 +255,13 @@ class List(Base):
 
         # common checks for group_by and default_sort_column
         for config_name in ["group_by", "default_sort_column"]:
-            if (
-                config_name in configuration
-                and configuration[config_name]
-                and configuration[config_name] not in self._columns
-            ):
+            value = configuration.get(config_name)
+            if not value:
+                continue
+            # we're being lazy for now and not checking complicated values
+            if "." in value:
+                continue
+            if value not in self._columns:
                 raise ValueError(
                     f"{error_prefix} '{config_name}' references column named {column_name} "
                     + f"but this column does not exist for model '{model_class_name}'"

clearskies/handlers/simple_routing_route.py

@@ -98,7 +98,7 @@ class SimpleRoutingRoute:
         to understand if there was no route match at all.
         """
         # if we're routing to a simple router then defer to it
-        incoming = f"Incoming request: [{request_method}] {full_path}.  Check against route with url '{self._path}' "
+        incoming = f"Incoming request: [{request_method}] {full_path}.  Check against route with url '{self._path}'.  Results: "
         if not self._methods:
             incoming += " configured for any method except OPTIONS"
         elif isinstance(self._methods, str):
@@ -136,7 +136,7 @@ class SimpleRoutingRoute:
                 return None
             # make sure we don't get confused by partial matches.  `user` should match `user/` and `user/5`,
             # but it shouldn't match `users/`
-            if full_path_length > my_path_length and full_path[my_path_length] != "/":
+            if full_path_length > my_path_length and full_path[my_path_length] != "/" and my_path != "":
                 logger.debug(f"{incoming} Not a match.  I only partially matched the URL but not as a sub-directory.")
                 return None
         logger.debug(f"{incoming} Match!")

clearskies/handlers/update.py

@@ -15,6 +15,7 @@ class Update(Write):
         "column_overrides": None,
         "writeable_columns": None,
         "readable_columns": None,
+        "output_map": None,
         "where": [],
         "input_error_callable": None,
         "include_id_in_path": False,

clearskies/handlers/write.py

@@ -22,6 +22,7 @@ class Write(Base, InputProcessing):
         "columns": None,
         "column_overrides": None,
         "writeable_columns": None,
+        "output_map": None,
         "readable_columns": None,
         "input_error_callable": None,
     }

clearskies/input_outputs/cli.py

@@ -21,7 +21,7 @@ class CLI:
         self._request_method = None
         self._parse_args(self._sys.argv)
 
-    def respond(self, response, status_code):
+    def respond(self, response, status_code=200):
         if status_code == 404:
             raise exceptions.CLINotFound()
         if status_code != 200:

clearskies/input_outputs/wsgi.py

@@ -21,7 +21,7 @@ class WSGI(InputOutput):
     def _from_environment(self, key):
         return self._environment[key] if key in self._environment else ""
 
-    def respond(self, body, status_code):
+    def respond(self, body, status_code=200):
         if not self.has_header("content-type"):
             self.set_header("content-type", "application/json; charset=UTF-8")
 

clearskies/input_requirements/__init__.py

@@ -1,16 +1,33 @@
+import datetime
+
+from .after import After
+from .before import Before
 from ..binding_config import BindingConfig
 from .minimum_length import MinimumLength
 from .maximum_length import MaximumLength
 from .required import Required
 from .requirement import Requirement
 from .unique import Unique
+from .in_the_future_at_least import InTheFutureAtLeast
+from .in_the_future_at_most import InTheFutureAtMost
+from .in_the_past_at_least import InThePastAtLeast
+from .in_the_past_at_most import InThePastAtMost
+from .time_delta import TimeDelta
+
+
+def after(other_column_name: str, allow_equal: bool = False):
+    return BindingConfig(After, other_column_name=other_column_name, allow_equal=allow_equal)
+
 
+def before(other_column_name: str, allow_equal: bool = False):
+    return BindingConfig(Before, other_column_name=other_column_name, allow_equal=allow_equal)
 
-def minimum_length(minimum_length):
+
+def minimum_length(minimum_length: int):
     return BindingConfig(MinimumLength, minimum_length)
 
 
-def maximum_length(maximum_length):
+def maximum_length(maximum_length: int):
     return BindingConfig(MaximumLength, maximum_length)
 
 
@@ -22,9 +39,30 @@ def unique():
     return BindingConfig(Unique)
 
 
+def in_the_future_at_least(time_delta: datetime.timedelta):
+    return BindingConfig(InTheFutureAtLeast, time_delta)
+
+
+def in_the_future_at_most(time_delta: datetime.timedelta):
+    return BindingConfig(InTheFutureAtMost, time_delta)
+
+
+def in_the_past_at_least(time_delta: datetime.timedelta):
+    return BindingConfig(InThePastAtLeast, time_delta)
+
+
+def in_the_past_at_most(time_delta: datetime.timedelta):
+    return BindingConfig(InThePastAtMost, time_delta)
+
+
 __all__ = [
+    "in_the_future_at_least",
+    "in_the_future_at_most",
+    "in_the_past_at_least",
+    "in_the_past_at_most",
     "minimum_length",
     "maximum_length",
     "required",
+    "TimeDelta",
     "unique",
 ]

clearskies/input_requirements/after.py

@@ -0,0 +1,36 @@
+from .requirement import Requirement
+import datetime
+import dateparser
+
+
+class After(Requirement):
+    def configure(self, other_column_name: str, allow_equal: bool = False):
+        self.other_column_name = other_column_name
+        self.allow_equal = allow_equal
+
+    def check(self, model, data):
+        # we won't check anything for missing values (columns should be required if that is an issue)
+        if not data.get(self.column_name):
+            return ""
+        my_value = data[self.column_name]
+        other_value = data.get(self.other_column_name, model.__getitem__(self.other_column_name))
+        # again, no checks for non-values
+        if not other_value:
+            return ""
+
+        my_value_as_date = dateparser.parse(data[self.column_name])
+        if not my_value_as_date:
+            return f"'{self.column_name}' was not a valid date."
+
+        if type(other_value) != str and type(other_value) != datetime.datetime:
+            return f"'{other_column_name}' was not a valid date."
+        other_value_as_date = dateparser.parse(other_value) if type(other_value) == str else other_value
+        if not other_value_as_date:
+            return f"'{self.other_column_name}' was not a valid date."
+
+        if my_value_as_date == other_value_as_date:
+            return "" if self.allow_equal else f"'{self.column_name}' must be after '{self.other_column_name}'"
+
+        if my_value_as_date < other_value_as_date:
+            return f"'{self.column_name}' must be after '{self.other_column_name}'"
+        return ""

clearskies/input_requirements/before.py

@@ -0,0 +1,36 @@
+from .requirement import Requirement
+import datetime
+import dateparser
+
+
+class Before(Requirement):
+    def configure(self, other_column_name: str, allow_equal: bool = False):
+        self.other_column_name = other_column_name
+        self.allow_equal = allow_equal
+
+    def check(self, model, data):
+        # we won't check anything for missing values (columns should be required if that is an issue)
+        if not data.get(self.column_name):
+            return ""
+        my_value = data[self.column_name]
+        other_value = data.get(self.other_column_name, model.__getitem__(self.other_column_name))
+        # again, no checks for non-values
+        if not other_value:
+            return ""
+
+        my_value_as_date = dateparser.parse(data[self.column_name])
+        if not my_value_as_date:
+            return f"'{self.column_name}' was not a valid date."
+
+        if type(other_value) != str and type(other_value) != datetime.datetime:
+            return f"'{other_column_name}' was not a valid date."
+        other_value_as_date = dateparser.parse(other_value) if type(other_value) == str else other_value
+        if not other_value_as_date:
+            return f"'{self.other_column_name}' was not a valid date."
+
+        if my_value_as_date == other_value_as_date:
+            return "" if self.allow_equal else f"'{self.column_name}' must be before '{self.other_column_name}'"
+
+        if my_value_as_date > other_value_as_date:
+            return f"'{self.column_name}' must be before '{self.other_column_name}'"
+        return ""

clearskies/input_requirements/in_the_future_at_least.py

@@ -0,0 +1,19 @@
+from .time_delta import TimeDelta
+import datetime
+import dateparser
+
+
+class InTheFutureAtLeast(TimeDelta):
+    def check(self, model, data):
+        if self.column_name not in data or not data[self.column_name]:
+            return ""
+        as_date = dateparser.parse(data[self.column_name])
+        if not as_date:
+            return f"'{self.column_name}' was not a valid date"
+        now = (
+            self.datetime.datetime.now() if not as_date.tzinfo else self.datetime.datetime.now(tz=datetime.timezone.utc)
+        )
+        if as_date < now + self.time_delta:
+            human_friendly = self.delta_human_friendly()
+            return f"'{self.column_name}' must be at least {human_friendly} in the future."
+        return ""

clearskies/input_requirements/in_the_future_at_most.py

@@ -0,0 +1,19 @@
+from .time_delta import TimeDelta
+import datetime
+import dateparser
+
+
+class InTheFutureAtMost(TimeDelta):
+    def check(self, model, data):
+        if self.column_name not in data or not data[self.column_name]:
+            return ""
+        as_date = dateparser.parse(data[self.column_name])
+        if not as_date:
+            return f"'{self.column_name}' was not a valid date"
+        now = (
+            self.datetime.datetime.now() if not as_date.tzinfo else self.datetime.datetime.now(tz=datetime.timezone.utc)
+        )
+        if as_date > now + self.time_delta:
+            human_friendly = self.delta_human_friendly()
+            return f"'{self.column_name}' must be at most {human_friendly} in the future."
+        return ""

clearskies/input_requirements/in_the_past_at_least.py

@@ -0,0 +1,19 @@
+from .time_delta import TimeDelta
+import datetime
+import dateparser
+
+
+class InThePastAtLeast(TimeDelta):
+    def check(self, model, data):
+        if self.column_name not in data or not data[self.column_name]:
+            return ""
+        as_date = dateparser.parse(data[self.column_name])
+        if not as_date:
+            return f"'{self.column_name}' was not a valid date"
+        now = (
+            self.datetime.datetime.now() if not as_date.tzinfo else self.datetime.datetime.now(tz=datetime.timezone.utc)
+        )
+        if as_date > now - self.time_delta:
+            human_friendly = self.delta_human_friendly()
+            return f"'{self.column_name}' must be at least {human_friendly} in the past."
+        return ""

clearskies/input_requirements/in_the_past_at_most.py

@@ -0,0 +1,19 @@
+from .time_delta import TimeDelta
+import datetime
+import dateparser
+
+
+class InThePastAtMost(TimeDelta):
+    def check(self, model, data):
+        if self.column_name not in data or not data[self.column_name]:
+            return ""
+        as_date = dateparser.parse(data[self.column_name])
+        if not as_date:
+            return f"'{self.column_name}' was not a valid date"
+        now = (
+            self.datetime.datetime.now() if not as_date.tzinfo else self.datetime.datetime.now(tz=datetime.timezone.utc)
+        )
+        if as_date < now - self.time_delta:
+            human_friendly = self.delta_human_friendly()
+            return f"'{self.column_name}' must be at most {human_friendly} in the past."
+        return ""

clearskies/input_requirements/time_delta.py

@@ -0,0 +1,38 @@
+from .requirement import Requirement
+import datetime
+from collections import OrderedDict
+
+
+class TimeDelta(Requirement):
+    time_delta = None
+
+    def __init__(self, datetime):
+        self.datetime = datetime
+
+    def configure(self, time_delta: datetime.timedelta):
+        if type(time_delta) != datetime.timedelta:
+            raise ValueError(
+                "The argument for all time-related input requirement classes is a datetime.timedelta object, but I received something else."
+            )
+        self.time_delta = time_delta
+        self.human_friendly = None
+
+    def delta_human_friendly(self):
+        remainder = int(self.time_delta.total_seconds())
+        parts = []
+        conversion = OrderedDict(
+            [
+                ("year", 31536000),
+                ("day", 86400),
+                ("hour", 3600),
+                ("minute", 60),
+                ("second", 1),
+            ]
+        )
+        for name, num_seconds in conversion.items():
+            if num_seconds > remainder:
+                continue
+            amount = int(remainder / num_seconds)
+            remainder -= amount * num_seconds
+            parts.append(f"{amount} {name}" + ("s" if amount != 1 else ""))
+        return ", ".join(parts)