Get Started with Code Examples

Decide and enforce withdrawal limits with custom hold times.

Compute income from Plaid transactions.

Bypass the cache with a max-staleness of 0.

Compute streaming window aggregate functions on sensor data.

Deploy to Chalk (either as a preview deployment or to production).

To run a Chalk resolver in airflow, you'll need to add CHALK_CLIENT_ID and CHALK_CLIENT_SECRET andCHALK_ENVIRONMENT environment variables to airflow.

Create Chalk features for Users and Sellers and evaluate whether a user and seller have matching categories.

Detect changes in user behavior over time.

Resolvers are just Python functions, so they are easy to unit test.

Resolvers are shared between all models.

Use pydantic, attrs, dataclasses.dataclass, or custom types as feature values.

Chain a DataFrame resolver with a scalar resolver.

Combine batch, caching, and DataFrames to create a powerful predictive maintenance pipeline.

Join a feature set back to itself.

Create features directly from messages on a stream.

Keep the cache warm by scheduling a resolver to run more frequently than the max-staleness.

Resolvers chain together through their required dependencies and declared outputs.

Access and override the time at which a feature should be recorded.

Integrate data from credit bureaus like Transunion.

First, we define features representing our users and their card transactions:

Filter the rows of a DataFrame by supplying conditions to the __getitem__() method.

To isolate the chalkpy dependency from your python environment, you can use airflow's @task.virtualenv decorator. Note, this is slightly slower since a python virtual environment is created for the task, but it might be a useful approach if you want to avoid conflicts with other python dependencies.

Tag related features.

Enrich User Interaction data with stream data.

Cache intermediate feature values.

Set up preview deployments for all PRs.

Aggregate failed logins over a Kafka stream.

Supply a feature value in the input to skip the cache and any resolver entirely.

Describe features at a feature class or feature level.

Describe features at a feature class or feature level.

Compute aggregates over a DataFrame.

Define a has-many relationship between feature classes.

Define a has-many relationship between feature classes.

Define a has-one relationship between feature classes.

Install the Chalk CLI in a GitHub Action.

Query scalars with SQL files or strings.

Cache the last computed example of the feature.

The example code below shows how to integrate a predictive model into a resolver.

Compute an aggregation on windows using DataFrames.

Scope down the set of rows available in a DataFrame.

Create a namespaced set of features.

Assign owners to features for monitoring and alerting.

Chalk also makes it easy to integrate LLMs like ChatGPT, into your resolvers. In the following example, we use Chat-GPT to answer questions about our Users.

Make use of vendor APIs to verify identities, control costs with Chalk's platform.

To wait for the resolver run to complete in airflow, you can use the get_run_status Chalk method to poll the status of the resolver run. One way to accomplish this is by using Airflow's Sensor framework.

Trigger special behavior with tags.

Test interactions between resolvers with preview deployments.

Create a resolver that returns a single feature.

Create a resolver that returns many features.

Set the primary key for an entity.

Compose projections and filters to create a new DataFrame.

In the rest of this readme, we will focus on the LLM-dependent features:completion, clean_memo, category, is_nsf, and is_ach. (You can check out the full code and our documentation to see how we resolve the rest of the features using SQL file resolvers and windowed aggregations.)

Easily listen to streaming data and parse messages with custom logic.

Access historical sensor data as-of any time in the past.

Compute a streaming window aggregate function using DataFrames.

Compute a streaming window aggregate function using DataFrames.

Assigning tags & owners to features.

Set max-staleness per-request.

Identify the number of interactions that have occurred between users and sellers.

Pick exactly the examples that you’d like to run.

Identify transactions returned for non-sufficient funds.

Create sets of features from your feature classes.

Cache feature values rather than computing them realtime.

Aggregate user statistics across tradelines.

Identify users with multiple accounts.

Run resolvers on a schedule and filter down which examples to consider.

Run resolvers on a schedule with all possible arguments.

Serve many end-customers with differentiated behavior.

Query many rows and take advantage of push down filters.