Package: incase
incaseA word case management library with too many features (just in case).Table of ContentsAbout The ProjectGetting StartedUsageContributingContactAbout The ProjectIncase is a library to help manage word case. It includes a class for abstracting away from case for easy comparison of words or conversion to any case.
Incase also includes a flexible decorator for managing the case of keywords, inputs, and outputs from functions.Currently, incase supports the following cases:
caseless, camel, dromedary, medial, snake, pascal, initial_capitals, kebab, dash, upper_snake, uppercase, upper, lowercase, lower, title, alternating, sarcasm, original, wordIf you are aware of another case, please open an issue so we can add it!Getting StartedTo get a local copy up and running follow these simple steps.Installing with pippipinstallincaseFor information about cloning and dev setup see:ContributingUsageCLIYou can leverage incase in shell scripts or other non-python contexts by calling it from the cli.
Example:The default output is snake case.$incasesomeCamel
some_camelUse the --case option to set output case$incasesomeCamel--caselower
somecamelCaselessHere is an example showing basic usage of the Caseless class.fromincaseimportCase,Caseless# Instances of Caseless are stringsexample=Caseless("example string")print(isinstance(example,str))# True# By propertyprint(example.snake)# example_string# Or by subscript (string or Case)print(example["camel"])# exampleStringprint(example[Case.UPPER_SNAKE])# EXAMPLE_STRING# Caseless ignore case when comparing to strprint(Caseless("some name")=="SOME_NAME")# True# Caseless hashes ignore case alsoa_dict={Caseless("This is a Key"):"this"}print(a_dict[Caseless("thisIsAKey")])# Caseless can also generate case coercion functionsmake_camel=Caseless.factory("camel")print(make_camel("snake_case"))# snakeCaseASGI Middleware UsageThis ASGI middleware,JSONCaseTranslatorMiddleware, translates JSON keys' case between snake_case and camelCase, easing communication between Python backends and JavaScript frontends. It handles JSON key case conversion for incoming and outgoing HTTP requests and responses.Example:fromincase.middlewareimportJSONCaseTranslatorMiddleware# Setup your FastAPI or Starlette application and then:app.add_middleware(JSONCaseTranslatorMiddleware)The middleware is ASGI compliant and should work as middleware with other frameworks but this has not been tested.Updated Usage Example:To effectively use JSONCaseTranslatorMiddleware in your FastAPI or Starlette application, it's recommended to use a custom response class (CamelJsonResponse) for outgoing data. This approach avoids the performance overhead associated with deserializing and re-serializing JSON in middleware.Here is how you can set it up to use the custom response with FastAPI. Note the argument to FastAPI to set the default_response_class and also the argument to add_middleware to disable response handling.fromfastapiimportFastAPIfromincase.middlewareimportJSONCaseTranslatorMiddleware,Request,CamelJsonResponseapp=FastAPI(default_response_class=CamelJsonResponse)app.add_middleware(JSONCaseTranslatorMiddleware,handle_response=False)@app.get("/")defread_root():return{"hello_there":"general kenobi"}@app.post("/")asyncdefreceive_data(request:Request):json_data=awaitrequest.json()print(json_data)return{"Received":json_data}The above app will return{"helloThere": "general kenobi"}at the root because the default_response_class will automatically change json keys to camel case. If you post the following json to the root ("/"):{"thisThing": 1}you will see{"Recieved": {"this_thing": 1}}because the middleware will intercept the incoming json and convert the keys to snake_case.See also:https://www.starlette.io/middleware/#using-middlewarehttps://fastapi.tiangolo.com/advanced/middleware/#advanced-middlewareHelper functionscase_modifier is a function for altering other functions. It can change the incoming case of parameter values, the case of the keywords provided, or the case of the function output.fromincaseimportCase,case_modifier# Some functions you don't controldefexternal_function(expectsCamel,iterationCount):# expects camelCase parameter namesforiinrange(iterationCount):print(expectsCamel)# We'll use case_modifier. Now any keyword will be turned to camelCasef=case_modifier(keywords_case=Case.CAMEL)(external_function)f(expects_camel="this",iteration_count=1)# this# Here, we'll use case modifier as a function decorator#  to give a sarcastic twist to our output@case_modifier(args_case="sarcasm")defsay_words(*args)->None:[print(word)forwordinargs]say_words("It's all about","the he said","SHE SAID")# It's aLl aBoUt# ThE He sAi# ShE SaIdFinally, incase is a powerful case coercion function.fromincaseimportincase# It covers the basic caseprint(incase("snake","example text"))# example_text# But can also handle sequencesprint(incase("upper",["three","word","list"]))# ['THREE', 'WORD', 'LIST']print(incase("upper",("three","word","tuple")))# ('THREE', 'WORD', 'TUPLE')# Even generatorsgenerator=(wordforwordin["some","list"])incased=incase("upper",generator)print(incased)# <generator object _incase_single.<locals>.<genexpr> at ...print(list(incased))# ['SOME', 'LIST']# Or nested objectsnested={"first_key":["some","list"],"second_key":{"another":"dict"},"third_key":1,}print(incase("upper",nested))# {"first_key": ["SOME", "LIST"], "second_key": {"another": "DICT"}, "third_key": 1}# Finally, it is possible to map case to objectsprint(incase(["upper","lower","snake","camel"],["some_word"]*4))# ['SOME WORD', 'some word', 'some_word', 'someWord']# By keyprint(incase({"first_key":"alternating","second_key":"title"},{"first_key":"some example","second_key":"another example"},))# {'first_key': 'SoMe eXaMpLe', 'second_key': 'Another Example'}print(incase({"bob":"upper"},"bob"))Planetary Defense ShieldNote that this is probably not a good idea. However, if you want to be able to easily access objects in globals() by a case other then the one they have, you can use the planetary defense shield.fromincaseimportplanetary_defense_shieldTHIS_IS_A_THING="Some Value"defbadCamelCaseFunction():print("hi")# If you pass a case, instead of a dictionary, this will grab most of globals.# Also note that the objects that will be cloned are whatever is in globals()# at the time you pass it as the second argument, so call accordingly.planetary_defense_shield({"THIS_IS_A_THING":"snake","badCamelCaseFunction":"snake"},globals())print(this_is_a_thing)# Some Valuebad_camel_case_function()# hiContributingContributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make aregreatly appreciated.Fork the ProjectCreate your Feature Branch (git checkout -b feature/AmazingFeature)Add tests, we aim for 100% test coverageUsing CoverageCommit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull RequestCloning / Development setupClone the repo and installgitclonehttps://github.com/kajuberdut/incase.gitcdincase
pipenvinstall--devRun testspipenvshell
wardFor more about pipenv see:Pipenv GithubLicenseDistributed under the MIT License. SeeLICENSEfor more information.ContactPatrick Shechet -patrick.shechet@gmail.comProject Link:https://github.com/kajuberdut/incase