GitLocker: The Coding Marketplace

Description:

pare 0.3.2

🔪 Pare

Pare is the easiest way to deploy Python Lambdas alongside your primary web application.
Discord

Why use Pare?
Pare is built to allow web developers to independently scale parts of a web application.
More specifically, Pare is useful if you have functions which are:

compute intensive
blocking
isolated
parallel

Some examples are document parsing, data aggregation, webhook handling and image processing.
With Pare, you can offload these tasks from your main web server, while also getting automatic scaling for concurrent requests.
Quickstart
> pip install pare

First, mark the function you want to deploy onto a Lambda:
import pare

@pare.endpoint(name="quickstart")
def my_function(*args, **kwargs):
...

This will tell Pare to use this function as the Lambda handler.
Calling the function in your code will still execute locally, but the decorator adds additional methods to make calls to the deployed Lambda.
from my_module import my_function

my_function(*args, **kwargs) # local function call

my_function.invoke(*args, **kwargs) # remote Lambda call

await my_function.invoke_async(*args, **kwargs) # async remote Lambda call

Next, login with Github to get a Pare API Key:
> pare login
Please visit: https://github.com/login/device
and enter code: 1111-1111

Following the on-screen instructions will authorize Gauge to retrieve your Github username and email for the purposes of account creation. The token has no other permissions.
After logging in, you can run a deploy of your function into the Pare Cloud:
> pare deploy my_module.py

[!NOTE]
This generally takes between 3s (when heavily cached) and 60s (no cache, heavy dependencies)

[!NOTE]
Make sure you are in a git repository. Pare uses the latest git hash to tag your deploy.

Once the deploy is finished, you can verify with pare status:
> pare status
Deployment Data
┏━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┓
┃ Name ┃ Git Hash ┃ Created At ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━┩
│ quickstart │ 8a4096b │ 2024-08-19 22:55:51 │
└────────────────────────┴──────────┴─────────────────────┘

That's it! Your function is now serverless.
To delete a deployed function, use pare delete:
> pare delete quickstart

Notes on Deployment
The pare deploy command accepts a sequence of file patterns (filepaths, directories, or glob paths).
The corresponding files will be collected into a single bundle, which will be built and deployed with each function.
The entrypoint for each function will be defined by pare.endpoint, and it is critical that
all of the entrypoint's imports are included in the bundle.
Third party dependencies are bundled
with each function individually, see the section below for more details.
In the future, we plan to use the technology behind [Tach] to automatically determine
the transitive dependencies in your project and create a complete bundle. Reach out on Discord
if this is an important feature for you!
Advanced Usage
3rd Party Dependencies
Pare allows installing 3rd party dependencies from PyPI for each deployed function.
Use the dependencies kwarg in the endpoint decorator to specify the dependencies for a function,
and they will automatically be installed during the deploy.
@pare.endpoint(name="3rd-party-deps", dependencies=["pydantic", ...])

The dependency names can specify version numbers as well, just as if they were listed in requirements.txt.
@pare.endpoint(name="3rd-party-deps", dependencies=["pydantic==2.8.2", ...])

[!TIP]
If you want to quickly determine the 3rd party dependencies used by a set of files, consider using Tach with tach report-external

Environment Variables
Pare allows setting environment variables for your functions during the deploy.
Use the -e option to set environment variables:
> pare deploy my_module.py -e MY_VARIABLE=myvalue -e OTHER_VARIABLE=othervalue [...]

Atomic Deployment
Pare supports 'atomic deployment' of services based on a git hash.
When atomic deployment is disabled (the default),
the Pare API will route requests by name to the latest deployed version of your function.
When atomic deployment is enabled, the Pare SDK will include the git hash in its requests to your deployed functions,
and the Pare API will route your request to the service with a matching git hash.
This feature is enabled on the client-side with the environment variable PARE_ATOMIC_DEPLOYMENT_ENABLED.
Since your main application likely will not have access to git to determine its git hash at runtime,
you will need to set the PARE_GIT_HASH environment variable during your build and deployment pipeline.