A word case management library with too many features (just in case).
Incase 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, word
If you are aware of another case, please open an issue so we can add it!
To get a local copy up and running follow these simple steps.
pip install incaseFor information about cloning and dev setup see: Contributing
You can leverage incase in shell scripts or other non-python contexts by calling it from the cli. Example:
The default output is snake case.
$ incase someCamel
some_camelUse the --case option to set output case
$ incase someCamel --case lower
some camelHere is an example showing basic usage of the Caseless class.
from incase import Case, Caseless
# Instances of Caseless are strings
example = Caseless("example string")
print(isinstance(example, str))
# True
# By property
print(example.snake)
# example_string
# Or by subscript (string or Case)
print(example["camel"])
# exampleString
print(example[Case.UPPER_SNAKE])
# EXAMPLE_STRING
# Caseless ignore case when comparing to str
print(Caseless("some name") == "SOME_NAME")
# True
# Caseless hashes ignore case also
a_dict = {Caseless("This is a Key"): "this"}
print(a_dict[Caseless("thisIsAKey")])
# Caseless can also generate case coercion functions
make_camel = Caseless.factory("camel")
print(make_camel("snake_case"))
# snakeCaseThis 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:
from incase.middleware import JSONCaseTranslatorMiddleware
# 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.
See also:
- https://www.starlette.io/middleware/#using-middleware
- https://fastapi.tiangolo.com/advanced/middleware/#advanced-middleware
case_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.
from incase import Case, case_modifier
# Some functions you don't control
def external_function(expectsCamel, iterationCount):
# expects camelCase parameter names
for i in range(iterationCount):
print(expectsCamel)
# We'll use case_modifier. Now any keyword will be turned to camelCase
f = 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")
def say_words(*args) -> None:
[print(word) for word in args]
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.
from incase import incase
# It covers the basic case
print(incase("snake", "example text"))
# example_text
# But can also handle sequences
print(incase("upper", ["three", "word", "list"]))
# ['THREE', 'WORD', 'LIST']
print(incase("upper", ("three", "word", "tuple")))
# ('THREE', 'WORD', 'TUPLE')
# Even generators
generator = (word for word in ["some", "list"])
incased = incase("upper", generator)
print(incased)
# <generator object _incase_single.<locals>.<genexpr> at ...
print(list(incased))
# ['SOME', 'LIST']
# Or nested objects
nested = {
"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 objects
print(incase(["upper", "lower", "snake", "camel"], ["some_word"] * 4))
# ['SOME WORD', 'some word', 'some_word', 'someWord']
# By key
print(
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"))Note 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.
from incase import planetary_defense_shield
THIS_IS_A_THING = "Some Value"
def badCamelCaseFunction():
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 Value
bad_camel_case_function()
# hiContributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make are greatly appreciated.
- Fork the Project
- Create your Feature Branch (
git checkout -b feature/AmazingFeature) - Add tests, we aim for 100% test coverage Using Coverage
- Commit your Changes (
git commit -m 'Add some AmazingFeature') - Push to the Branch (
git push origin feature/AmazingFeature) - Open a Pull Request
- Clone the repo and install
git clone https://github.com/kajuberdut/incase.git cd incase pipenv install --dev - Run tests
pipenv shell ward
For more about pipenv see: Pipenv Github
Distributed under the MIT License. See LICENSE for more information.
Patrick Shechet - patrick.shechet@gmail.com
Project Link: https://github.com/kajuberdut/incase