About suitkaise

For technical info, see the technical info page.

suitkaise is a Python code library.

It's for developers of all skill levels, and was created with 3 main goals in mind:

1. To make things easier and faster for all developers.
2. To bridge the knowledge gap for inexperienced developers to create professional level programs
3. Change the world of parallel processing in Python

There are many things in Python that are difficult or nuanced for beginners, and many more that are just annoying, overwhelming, and time consuming for all developers.

I have taken a few of the most foundational and useful parts of modern Python and made them faster, clearer, and easier to use.

Every module I have made started as a "dream API".

"If it could just be like this..."

"If it worked like this..."

"I would use this so much more if it looked like this..."

I created things that I wished worked like the concepts I wrote. Then I went backwards to actually make it work.

What suitkaise does

Think of the printing press, an invention that made production of paper media faster, more standardized, and less prone to human error. People didn't have to write books by hand anymore, saving them a large amount of time and effort.

The result: the world was flooded with books, and the "Information Age" began.

There are many things in Python that need their own printing press to make using them faster, more standardized, and less prone to human error.

Parallel processing, Python-to-Python serialization, file path handling, and more.

suitkaise gives you these printing presses.

The name is inspired by "hacker laptops", where the user opens a briefcase and hacks some mainframe in 5 seconds. That's the level of speed and ease you get with suitkaise.

processing — Unlocks the full potential of parallel programming in Python.

60% of parallel processing is batch processing, where you process N number of items at once instead of just 1. processing gives you a Pool class that makes batch processing easy, with 3 standard pooling patterns.

The other 40% is creating long-running, complex subprocesses that do more than just look up data or compute something. Creating these is generally a nightmare even for experienced developers.

processing gives you an Skprocess class that makes creating these easy, with coded lifecycle methods to setup, run, cleanup, and more. These classes include timing, error handling, and run the process internally, so you don't have to worry about managing the process yourself.

Finally, processing gives you a Share class.

Every developer knows how to create a class instance and add objects to it.

And that's all you have to do with Share. Instantiate it, add objects to it, and pass it to your subprocesses. It ensures that everything syncs up and remains in sync for you. Even complex classes can be added and used just like you would use it normally.

How? cucumber, the serialization engine that can handle a vast amount of things that pickle, cloudpickle, and dill cannot, including complex, user created class instances that would fail to serialize with the other options.

cucumber — Serialize anything.

cucumber outperforms all competitors in coverage, almost entirely eliminating errors when converting to and from bytes. Things like locks, generators, file handles, and more are all covered. Additionally, it has faster speed than cloudpickle and dill for many simple types, and is also faster in most cases for the more complex types as well.

Why is this awesome? You don't have to worry about errors anymore. You now have access to a custom class, the objects you want to use in it but couldn't before, and the ability to just share data between processes without thinking, all powered by this engine. You don't even have to use the other modules to get an upgrade. This is just simply better.

paths — Everything path related is so much more simple.

It includes Skpath, a path object that uses an auto-detected project root to normalize all of your paths for you. It is cross platform compatible. An Skpath made on Murphy's Mac will be the same as the same Skpath made on Gurphy's Windows laptop.

It also includes an @autopath decorator that can be used to automatically streamline all of your paths to a specific type, getting rid of type mismatches in their entirety.

timing — Times your code with one line.

timing gives you a Sktimer class that is the core piece of this module. It powers @timethis and the TimeThis context manager, which allow you to time your code with one line.

Additionally, Sktimer collects far more statistical data than timeit, including mean, median, standard deviation, percentiles, and more.

circuits — Manage your execution flow more cleanly.

circuits gives you two patterns to manage your code. What separates them from other circuit breaker libraries is their use in parallel processing.

• Circuit — auto-resets after sleeping, great for rate limiting, resource management, and more
• BreakingCircuit — stays broken until manually reset, great for stopping execution after a certain number of failures with extra control

circuits is fully thread-safe.

BreakingCircuit also works with Share, so you can share the circuit breaker state across process boundaries.

sk — Modify your functions and methods without changing their code.

sk can be used as a decorator or a function, and adds some special modifiers to your functions and methods.

• .retry() — retry it when it fails
• .timeout() — return an error if it takes too long
• .background() — run it in the background and get the result later using Futures
• .asynced() — get an async version of it if it has calls that block your code from running using asyncio.to_thread()
• .rate_limit() — limit the number of calls it makes per second

Why you should use suitkaise

suitkaise is for the developer.

As previously mentioned, when I created suitkaise, I made the end goal first: what I myself as a developer would want to use.

All of suitkaise is thousands of iterations improving on this goal API, which was created to address different problems I myself have encountered as a developer.

Here are the problems that suitkaise was made for.

from suitkaise.processing import Skprocess

class MyProcess(Skprocess):

    def __init__(self, num_runs: int):
        self.counter = 0
        self.process_config.runs = num_runs

    def __prerun__(self):
        # setup before the main part
        # connect to databases, make API calls, read files

    def __run__(self):
        # the main part
        # write your code here
        # it repeats for you, no need to write looping code

    def __postrun__(self):
        # clean up your work
        # close connections, add results to attributes

    def __onfinish__(self):
        # clean up the process
        # calculate summaries, save results to files, send emails

    def __result__(self):
        # return the result of the process
        # store your results as instance attributes and return them here

    def __error__(self):
        # __result__() when an error occurs

p = MyProcess(num_runs=10)

# start the process
p.start()

# wait for the process to finish
p.wait()

# access the result
result = p.result

TypeError: cannot pickle 'MyObject' object

from suitkaise.timing import timethis

@timethis()
def my_function():
    do_work()

for _ in range(100):
    my_function()

print(my_function.timer.mean)
print(my_function.timer.percentile(95))

Using suitkaise with AI

Currently, AI agents like ChatGPT that you use with something like Cursor are not trained to use suitkaise.

That doesn't mean you can't use suitkaise with AI.

Install the docs and place them in your project

The docs are available for download through the suitkaise CLI.

1. pip install suitkaise
2. Add a setup.sk file to your project root
3. With your cwd inside the project root, run suitkaise docs from the terminal to download the docs to your project root.

Once you do this, AI agents will have access to the docs, including a detailed API reference for each module and internal workings.

Use this prompt:

I am using suitkaise, a Python code library.

The docs for the lib are attached under suitkaise-docs.

Please read them and familiarize yourself with the library before continuing.

How to give feedback

There are multiple ways to give feedback or report bugs. I am most likely to check the feedback forms first.

• Use the feedback page
• Use the GitHub issues page
• Use the Discord server
• Use the Reddit subreddit
• Email suitkaise@suitkaise.info
• DM any suitkaise social media account