Rename lookup_join -> join_lookup for consistency (#910)

Author: daniil-quix

docs/api-reference/dataframe.md

@@ -1594,21 +1594,21 @@ StreamingDataFrame: The same StreamingDataFrame instance with the enrichment app
 
 **Example**:
 
-  
 ```python
 from quixstreams import Application
-from quixstreams.dataframe.joins.lookups import QuixConfigurationService, QuixConfigurationServiceField as Field
+from quixstreams.dataframe.joins.lookups import QuixConfigurationService,
+  QuixConfigurationServiceField as Field
 
 app = Application()
 
 sdf = app.dataframe(app.topic("input"))
 lookup = QuixConfigurationService(app.topic("config"), config=app.config)
 
 fields = {
-    "test": Field(type="test", default="test_default")
+  "test": Field(type="test", default="test_default")
 }
 
-sdf = sdf.lookup_join(lookup, fields)
+sdf = sdf.join_lookup(lookup, fields)
 ```
 
 <a id="quixstreams.dataframe.dataframe.StreamingDataFrame.register_store"></a>
@@ -2293,32 +2293,34 @@ Rows will be deserialized into a dictionary with column names as keys.
 
 **Example**:
 
-  
 ```python
     lookup = SQLiteLookup(path="/path/to/db.sqlite")
 
-    # Select the value in `col1` from the table `my_table` where `col2` matches the `sdf.lookup_join` on parameter.
-    fields = {"my_field": SQLiteLookupField(table="my_table", columns=["col1", "col2"], on="col2")}
+# Select the value in `col1` from the table `my_table` where `col2` matches the `sdf.lookup_join` on parameter.
+fields = {
+  "my_field": SQLiteLookupField(table="my_table", columns=["col1", "col2"], on="col2")}
 
-    # After the lookup the `my_field` column in the message will contains:
-    # {"col1": <row1 col1 value>, "col2": <row1 col2 value>}
-    sdf = sdf.lookup_join(lookup, fields)
+# After the lookup the `my_field` column in the message will contains:
+# {"col1": <row1 col1 value>, "col2": <row1 col2 value>}
+sdf = sdf.join_lookup(lookup, fields)
 ```
-  
+
 ```python
     lookup = SQLiteLookup(path="/path/to/db.sqlite")
 
-    # Select the value in `col1` from the table `my_table` where `col2` matches the `sdf.lookup_join` on parameter.
-    fields = {"my_field": SQLiteLookupField(table="my_table", columns=["col1", "col2"], on="col2", first_match_only=False)}
+# Select the value in `col1` from the table `my_table` where `col2` matches the `sdf.lookup_join` on parameter.
+fields = {
+  "my_field": SQLiteLookupField(table="my_table", columns=["col1", "col2"], on="col2",
+                                first_match_only=False)}
 
-    # After the lookup the `my_field` column in the message will contains:
-    # [
-    #   {"col1": <row1 col1 value>, "col2": <row1 col2 value>},
-    #   {"col1": <row2 col1 value>, "col2": <row2 col2 value>},
-    #   ...
-    #   {"col1": <rowN col1 value>, "col2": <rowN col2 value>,},
-    # ]
-    sdf = sdf.lookup_join(lookup, fields)
+# After the lookup the `my_field` column in the message will contains:
+# [
+#   {"col1": <row1 col1 value>, "col2": <row1 col2 value>},
+#   {"col1": <row2 col1 value>, "col2": <row2 col2 value>},
+#   ...
+#   {"col1": <rowN col1 value>, "col2": <rowN col2 value>,},
+# ]
+sdf = sdf.join_lookup(lookup, fields)
 ```
 
 
@@ -2409,32 +2411,34 @@ Query results are returned as tuples of values, without additional deserializati
 
 **Example**:
 
-  
 ```python
     lookup = SQLiteLookup(path="/path/to/db.sqlite")
 
-    # Select all columns from the first row of `my_table` where `col2` matches the value of `field1` in the message.
-    fields = {"my_field": SQLiteLookupQueryField("SELECT * FROM my_table WHERE col2 = :field1")}
+# Select all columns from the first row of `my_table` where `col2` matches the value of `field1` in the message.
+fields = {
+  "my_field": SQLiteLookupQueryField("SELECT * FROM my_table WHERE col2 = :field1")}
 
-    # After the lookup, the `my_field` column in the message will contain:
-    # [<row1 col1 value>, <row1 col2 value>, ..., <row1 colN value>]
-    sdf = sdf.lookup_join(lookup, fields)
+# After the lookup, the `my_field` column in the message will contain:
+# [<row1 col1 value>, <row1 col2 value>, ..., <row1 colN value>]
+sdf = sdf.join_lookup(lookup, fields)
 ```
-  
+
 ```python
     lookup = SQLiteLookup(path="/path/to/db.sqlite")
 
-    # Select all columns from all rows of `my_table` where `col2` matches the value of `field1` in the message.
-    fields = {"my_field": SQLiteLookupQueryField("SELECT * FROM my_table WHERE col2 = :field1", first_match_only=False)}
+# Select all columns from all rows of `my_table` where `col2` matches the value of `field1` in the message.
+fields = {
+  "my_field": SQLiteLookupQueryField("SELECT * FROM my_table WHERE col2 = :field1",
+                                     first_match_only=False)}
 
-    # After the lookup, the `my_field` column in the message will contain:
-    # [
-    #   [<row1 col1 value>, <row1 col2 value>, ..., <row1 colN value>],
-    #   [<row2 col1 value>, <row2 col2 value>, ..., <row2 colN value>],
-    #   ...
-    #   [<rowN col1 value>, <rowN col2 value>, ..., <rowN colN value>],
-    # ]
-    sdf = sdf.lookup_join(lookup, fields)
+# After the lookup, the `my_field` column in the message will contain:
+# [
+#   [<row1 col1 value>, <row1 col2 value>, ..., <row1 colN value>],
+#   [<row2 col1 value>, <row2 col2 value>, ..., <row2 colN value>],
+#   ...
+#   [<rowN col1 value>, <rowN col2 value>, ..., <rowN colN value>],
+# ]
+sdf = sdf.join_lookup(lookup, fields)
 ```
 
 
@@ -2490,11 +2494,11 @@ based on a configurable TTL. The cache is a least recently used (LRU) cache with
 
 **Example**:
 
-  
 ```python
     lookup = SQLiteLookup(path="/path/to/db.sqlite")
-    fields = {"my_field": SQLiteLookupField(table="my_table", columns=["col2"], on="primary_key_col")}
-    sdf = sdf.lookup_join(lookup, fields)
+fields = {"my_field": SQLiteLookupField(table="my_table", columns=["col2"],
+                                        on="primary_key_col")}
+sdf = sdf.join_lookup(lookup, fields)
 ```
 
 

docs/api-reference/quixstreams.md

@@ -2337,7 +2337,8 @@ Example:
 
 ```python
 from quixstreams import Application
-from quixstreams.dataframe.joins.lookups import QuixConfigurationService, QuixConfigurationServiceField as Field
+from quixstreams.dataframe.joins.lookups import QuixConfigurationService,
+    QuixConfigurationServiceField as Field
 
 app = Application()
 
@@ -2348,7 +2349,7 @@ fields = {
     "test": Field(type="test", default="test_default")
 }
 
-sdf = sdf.lookup_join(lookup, fields)
+sdf = sdf.join_lookup(lookup, fields)
 ```
 
 <a id="quixstreams.dataframe.dataframe.StreamingDataFrame.register_store"></a>
@@ -2899,28 +2900,31 @@ Example:
 ```python
     lookup = SQLiteLookup(path="/path/to/db.sqlite")
 
-    # Select the value in `col1` from the table `my_table` where `col2` matches the `sdf.lookup_join` on parameter.
-    fields = {"my_field": SQLiteLookupField(table="my_table", columns=["col1", "col2"], on="col2")}
+# Select the value in `col1` from the table `my_table` where `col2` matches the `sdf.lookup_join` on parameter.
+fields = {"my_field": SQLiteLookupField(table="my_table", columns=["col1", "col2"],
+                                        on="col2")}
 
-    # After the lookup the `my_field` column in the message will contains:
-    # {"col1": <row1 col1 value>, "col2": <row1 col2 value>}
-    sdf = sdf.lookup_join(lookup, fields)
+# After the lookup the `my_field` column in the message will contains:
+# {"col1": <row1 col1 value>, "col2": <row1 col2 value>}
+sdf = sdf.join_lookup(lookup, fields)
 ```
 
 ```python
     lookup = SQLiteLookup(path="/path/to/db.sqlite")
 
-    # Select the value in `col1` from the table `my_table` where `col2` matches the `sdf.lookup_join` on parameter.
-    fields = {"my_field": SQLiteLookupField(table="my_table", columns=["col1", "col2"], on="col2", first_match_only=False)}
+# Select the value in `col1` from the table `my_table` where `col2` matches the `sdf.lookup_join` on parameter.
+fields = {
+    "my_field": SQLiteLookupField(table="my_table", columns=["col1", "col2"], on="col2",
+                                  first_match_only=False)}
 
-    # After the lookup the `my_field` column in the message will contains:
-    # [
-    #   {"col1": <row1 col1 value>, "col2": <row1 col2 value>},
-    #   {"col1": <row2 col1 value>, "col2": <row2 col2 value>},
-    #   ...
-    #   {"col1": <rowN col1 value>, "col2": <rowN col2 value>,},
-    # ]
-    sdf = sdf.lookup_join(lookup, fields)
+# After the lookup the `my_field` column in the message will contains:
+# [
+#   {"col1": <row1 col1 value>, "col2": <row1 col2 value>},
+#   {"col1": <row2 col1 value>, "col2": <row2 col2 value>},
+#   ...
+#   {"col1": <rowN col1 value>, "col2": <rowN col2 value>,},
+# ]
+sdf = sdf.join_lookup(lookup, fields)
 ```
 
 **Arguments**:
@@ -3000,28 +3004,31 @@ Example:
 ```python
     lookup = SQLiteLookup(path="/path/to/db.sqlite")
 
-    # Select all columns from the first row of `my_table` where `col2` matches the value of `field1` in the message.
-    fields = {"my_field": SQLiteLookupQueryField("SELECT * FROM my_table WHERE col2 = :field1")}
+# Select all columns from the first row of `my_table` where `col2` matches the value of `field1` in the message.
+fields = {
+    "my_field": SQLiteLookupQueryField("SELECT * FROM my_table WHERE col2 = :field1")}
 
-    # After the lookup, the `my_field` column in the message will contain:
-    # [<row1 col1 value>, <row1 col2 value>, ..., <row1 colN value>]
-    sdf = sdf.lookup_join(lookup, fields)
+# After the lookup, the `my_field` column in the message will contain:
+# [<row1 col1 value>, <row1 col2 value>, ..., <row1 colN value>]
+sdf = sdf.join_lookup(lookup, fields)
 ```
 
 ```python
     lookup = SQLiteLookup(path="/path/to/db.sqlite")
 
-    # Select all columns from all rows of `my_table` where `col2` matches the value of `field1` in the message.
-    fields = {"my_field": SQLiteLookupQueryField("SELECT * FROM my_table WHERE col2 = :field1", first_match_only=False)}
+# Select all columns from all rows of `my_table` where `col2` matches the value of `field1` in the message.
+fields = {
+    "my_field": SQLiteLookupQueryField("SELECT * FROM my_table WHERE col2 = :field1",
+                                       first_match_only=False)}
 
-    # After the lookup, the `my_field` column in the message will contain:
-    # [
-    #   [<row1 col1 value>, <row1 col2 value>, ..., <row1 colN value>],
-    #   [<row2 col1 value>, <row2 col2 value>, ..., <row2 colN value>],
-    #   ...
-    #   [<rowN col1 value>, <rowN col2 value>, ..., <rowN colN value>],
-    # ]
-    sdf = sdf.lookup_join(lookup, fields)
+# After the lookup, the `my_field` column in the message will contain:
+# [
+#   [<row1 col1 value>, <row1 col2 value>, ..., <row1 colN value>],
+#   [<row2 col1 value>, <row2 col2 value>, ..., <row2 colN value>],
+#   ...
+#   [<rowN col1 value>, <rowN col2 value>, ..., <rowN colN value>],
+# ]
+sdf = sdf.join_lookup(lookup, fields)
 ```
 
 **Arguments**:
@@ -3071,8 +3078,9 @@ Example:
 
 ```python
     lookup = SQLiteLookup(path="/path/to/db.sqlite")
-    fields = {"my_field": SQLiteLookupField(table="my_table", columns=["col2"], on="primary_key_col")}
-    sdf = sdf.lookup_join(lookup, fields)
+fields = {"my_field": SQLiteLookupField(table="my_table", columns=["col2"],
+                                        on="primary_key_col")}
+sdf = sdf.join_lookup(lookup, fields)
 ```
 
 **Arguments**:

docs/joins.md

@@ -153,7 +153,7 @@ If you change timestamps of the record during processing, they will be processed
     This is an experimental feature; the API may change in future releases.
 
 
-`StreamingDataFrame.lookup_join()` is a special type of join that allows you to enrich records in a streaming dataframe with the data from external systems.  
+`StreamingDataFrame.join_lookup()` is a special type of join that allows you to enrich records in a streaming dataframe with the data from external systems.  
 
 You can use it to enriching streaming data with configuration or reference data from an external source, like a database.
 
@@ -163,7 +163,7 @@ To perform a lookup join, you need:
 
 1. A subclass of [quixstreams.dataframe.joins.lookups.base.BaseLookup](api-reference/dataframe.md#baselookup) to query the external source and cache the results when necessary.
 2. A subclass of [quixstreams.dataframe.joins.lookups.base.BaseField](api-reference/dataframe.md#basefield) to define how the data is extracted from the result.
-3. To pass the lookup and the fields to the `StreamingDataFrame.lookup_join`.
+3. To pass the lookup and the fields to the `StreamingDataFrame.join_lookup`.
 
 
 See [SQLiteLookup](api-reference/dataframe.md#sqlitelookup) and [SQLiteLookupField](api-reference/dataframe.md#sqlitelookupfield) for the reference implementation. 
@@ -177,13 +177,13 @@ from quixstreams.dataframe.joins.lookups import SQLiteLookup, SQLiteLookupField
 app = Application(...)
 
 # An implementation of BaseLookup for SQLite 
-lookup = SQLiteLookup(path="db.db")  
+lookup = SQLiteLookup(path="db.db")
 
 sdf = app.dataframe(app.topic("input"))
 
-sdf = sdf.lookup_join(
+sdf = sdf.join_lookup(
     lookup,
-    on="column", # A column in StreamingDataFrame to join on
+    on="column",  # A column in StreamingDataFrame to join on
     fields={
         # A mapping with SQLite fields to join with 
         "lookup": SQLiteLookupField(table="table", columns=["column"], on="id"),

quixstreams/dataframe/dataframe.py

@@ -1722,7 +1722,7 @@ def join_asof(
             how=how, on_merge=on_merge, grace_ms=grace_ms, store_name=name
         ).join(self, right)
 
-    def lookup_join(
+    def join_lookup(
         self,
         lookup: BaseLookup,
         fields: dict[str, BaseField],
@@ -1765,7 +1765,7 @@ def lookup_join(
             "test": Field(type="test", default="test_default")
         }
 
-        sdf = sdf.lookup_join(lookup, fields)
+        sdf = sdf.join_lookup(lookup, fields)
         ```
         """
         if callable(on):

quixstreams/dataframe/joins/lookups/base.py

@@ -14,7 +14,7 @@ class BaseLookup(abc.ABC, Generic[F]):
     This class defines the interface for lookup joins, where incoming records are enriched with external data based on a key and
     a set of fields. Subclasses should implement the `join` method to specify how enrichment is performed.
 
-    Typical usage involves passing an instance of a subclass to `StreamingDataFrame.lookup_join`, along with a mapping of field names
+    Typical usage involves passing an instance of a subclass to `StreamingDataFrame.join_lookup`, along with a mapping of field names
     to BaseField instances that describe how to extract or map enrichment data.
 
     Example:

quixstreams/dataframe/joins/lookups/quix_configuration_service/lookup.py

@@ -39,7 +39,7 @@ class Lookup(BaseLookup[Field]):
 
     Usage:
         - Instantiate with a configuration topic and (optionally) application config or connection details.
-        - Use as the `lookup` argument in `StreamingDataFrame.lookup_join()` with a mapping of field names to Field objects.
+        - Use as the `lookup` argument in `StreamingDataFrame.join_lookup()` with a mapping of field names to Field objects.
         - The `join` method is called for each record to enrich, updating the record in-place with configuration data.
 
     Features:
@@ -50,7 +50,7 @@ class Lookup(BaseLookup[Field]):
 
     Example:
         lookup = Lookup(topic, app_config=app.config)
-        sdf = sdf.lookup_join(lookup, fields)
+        sdf = sdf.join_lookup(lookup, fields)
     """
 
     def __init__(