kodexa 7.0.12396164812__tar.gz → 7.0.12397101638__tar.gz

{kodexa-7.0.12396164812 → kodexa-7.0.12397101638}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kodexa
-Version: 7.0.12396164812
+Version: 7.0.12397101638
 Summary: Python SDK for the Kodexa Platform
 Author: Austin Redenbaugh
 Author-email: austin@kodexa.com

{kodexa-7.0.12396164812 → kodexa-7.0.12397101638}/kodexa/model/model.py

@@ -293,8 +293,6 @@ class ContentNode(object):
         if content is not None and len(self.get_content_parts()) == 0:
             self.set_content_parts([content])
 
-        self.cached_all_content = None
-
     def get_content_parts(self):
         return self.document.get_persistence().get_content_parts(self)
 
@@ -793,12 +791,13 @@ class ContentNode(object):
         result = self.select(selector, variables)
         return result[0] if len(result) > 0 else None
 
-    def select(self, selector, variables=None):
+    def select(self, selector, variables=None, first_only=False):
         """Select and return the child nodes of this node that match the selector value.
 
         Args:
           selector (str): The selector (ie. //*)
           variables (dict, optional): A dictionary of variable name/value to use in substituion; defaults to None.  Dictionary keys should match a variable specified in the selector.
+          first_only (bool, optional): If True, only the first matching node will be returned; defaults to False.
 
         Returns:
           list[ContentNode]: A list of the matching content nodes.  If no matches are found, the list will be empty.
@@ -815,18 +814,17 @@ class ContentNode(object):
         from kodexa.selectors import parse
         from kodexa.selectors.ast import SelectorContext
 
-        context = SelectorContext(self.document)
+        context = SelectorContext(self.document, first_only=first_only)
         parsed_selector = parse(selector)
         self.document.get_persistence().flush_cache()
         return parsed_selector.resolve(self, variables, context)
 
-    def get_all_content(self, separator=" ", strip=True, use_cache=False):
+    def get_all_content(self, separator=" ", strip=True):
         """Get this node's content, concatenated with all of its children's content.
 
         Args:
           separator(str, optional): The separator to use in joining content together; defaults to " ".
           strip(boolean, optional): Strip the result
-          use_cache(boolean, optional): Use the cache
 
         Returns:
           str: The complete content for this node concatenated with the content of all child nodes.
@@ -836,9 +834,6 @@ class ContentNode(object):
             "This string is made up of multiple nodes"
         """
         s = ""
-        if self.cached_all_content is not None and use_cache:
-            return self.cached_all_content
-
         children = self.get_content_parts()
         for part in children:
             if isinstance(part, str):
@@ -861,14 +856,13 @@ class ContentNode(object):
                     s += separator
                 s += child.get_all_content(separator, strip=strip)
 
-        self.cached_all_content = s.strip() if strip else s
-        return self.cached_all_content
+        return s.strip() if strip else s
 
     def adopt_children(self, nodes_to_adopt, replace=False):
         """This will take a list of content nodes and adopt them under this node, ensuring they are re-parented.
 
         Args:
-          children (List[ContentNode]): A list of ContentNodes that will be added to the end of this node's children collection
+          nodes_to_adopt (List[ContentNode]): A list of ContentNodes that will be added to the end of this node's children collection
           replace (bool): If True, will remove all current children and replace them with the new list; defaults to True
 
         >>> # select all nodes of type 'line', then the root node 'adopts' them
@@ -3109,17 +3103,18 @@ class Document(object):
         >>> document.get_root().select_first('//*[hasTag($tagName)]', {"tagName": "div"})
            ContentNode
         """
-        result = self.select(selector, variables)
+        result = self.select(selector, variables, first_only=True)
         return result[0] if len(result) > 0 else None
 
     def select(
-            self, selector: str, variables: Optional[dict] = None
+            self, selector: str, variables: Optional[dict] = None, first_only=False
     ) -> List[ContentNode]:
         """Execute a selector on the root node and then return a list of the matching nodes.
 
         Args:
           selector (str): The selector (ie. //*)
           variables (Optional[dict): A dictionary of variable name/value to use in substituion; defaults to an empty
+          first_only (bool): If True, only the first matching node is returned; defaults to False.
           dictionary.  Dictionary keys should match a variable specified in the selector.
 
         Returns:
@@ -3131,7 +3126,7 @@ class Document(object):
         if variables is None:
             variables = {}
         if self.content_node:
-            result = self.content_node.select(selector, variables)
+            result = self.content_node.select(selector, variables, first_only)
             if isinstance(result, list):
                 return result
 

{kodexa-7.0.12396164812 → kodexa-7.0.12397101638}/kodexa/model/persistence.py

@@ -96,6 +96,7 @@ class SqliteDocumentPersistence(object):
         self.cursor.execute("PRAGMA journal_mode=OFF")
         self.cursor.execute("pragma temp_store = memory")
         self.cursor.execute("pragma mmap_size = 30000000000")
+        self.cursor.execute("pragma cache_size = 10000")  # Set the cache size to 10,000 pages
 
         try:
             # We need to populate node_type_id_by_name
@@ -835,9 +836,10 @@ class SqliteDocumentPersistence(object):
         self.connection.commit()
         self.cursor.execute("VACUUM")
         self.cursor = self.connection.cursor()
-        self.cursor.execute("PRAGMA journal_mode=OFF")
+        self.cursor.execute("pragma journal_mode=OFF")
         self.cursor.execute("pragma temp_store = memory")
         self.cursor.execute("pragma mmap_size = 30000000000")
+        self.cursor.execute("pragma cache_size = 10000")  # Set the cache size to 10,000 pages
 
     def dump_in_memory_db_to_file(self):
         # Connect to a new or existing database file

{kodexa-7.0.12396164812 → kodexa-7.0.12397101638}/kodexa/selectors/ast.py

@@ -36,11 +36,12 @@ __all__ = [
 
 
 class SelectorContext:
-    def __init__(self, document: Document):
+    def __init__(self, document: Document, first_only=False):
         self.pattern_cache = {}
         self.last_op = None
         self.document: Document = document
         self.stream = 0
+        self.first_only = first_only
 
     def cache_pattern(self, pattern):
         if pattern not in self.pattern_cache:
@@ -53,20 +54,26 @@ class PipelineExpression(object):
 
     def __init__(self, left, op, right):
         self.left = left
-        """the left side of the pipeline expression"""
         self.op = op
-        """the operator of the pipeline expression"""
         self.right = right
-        """the right side of the pipeline expression"""
 
     def resolve(self, content_node: ContentNode, variables, context: SelectorContext):
         left_nodes = self.left.resolve(content_node, variables, context)
         result_nodes: List[ContentNode] = []
         context.stream = context.stream + 1
-        for node in left_nodes:
-            result_nodes.extend(self.right.resolve(node, variables, context))
+
+        # If first_only is True and we already have left nodes, only process the first one
+        nodes_to_process = left_nodes[:1] if context.first_only and left_nodes else left_nodes
+
+        for node in nodes_to_process:
+            right_results = self.right.resolve(node, variables, context)
+            result_nodes.extend(right_results)
+            # If first_only is True and we found a match, return immediately
+            if context.first_only and result_nodes:
+                break
+
         context.stream = context.stream - 1
-        return result_nodes
+        return result_nodes[:1] if context.first_only else result_nodes
 
 
 class UnaryExpression(object):
@@ -181,17 +188,12 @@ class AbsolutePath(object):
 
 
 class Step(object):
-    """
-    A single step in a relative path. a; @b; text(); parent::foo:bar[5].
-    """
+    """A single step in a relative path."""
 
     def __init__(self, axis, node_test, predicates):
         self.axis = axis
-        """the step's axis, or @ or None if abbreviated or undefined"""
         self.node_test = node_test
-        """a NameTest or NodeType object describing the test represented"""
         self.predicates = predicates
-        """a list of predicates filtering the step"""
 
     def resolve(self, obj, variables, context: SelectorContext):
         match = True
@@ -217,8 +219,9 @@ class Step(object):
                 return []
 
             nodes = self.node_test.test(axis_node, variables, context)
-
             final_nodes = []
+
+            # If first_only is True, only process until we find the first match
             for node in nodes:
                 match = True
                 for predicate in self.predicates:
@@ -230,6 +233,8 @@ class Step(object):
 
                 if match:
                     final_nodes.append(node)
+                    if context.first_only:
+                        break
 
             return final_nodes
 
@@ -247,9 +252,7 @@ class NameTest(object):
 
     def __init__(self, prefix, name):
         self.prefix = prefix
-        """the namespace prefix used for the test, or None if unset"""
         self.name = name
-        """the node name used for the test, or *"""
 
     def test(self, obj, variables, context: SelectorContext):
         if isinstance(obj, ContentNode):
@@ -257,12 +260,15 @@ class NameTest(object):
                 if self.name == "*" or self.name == obj.node_type:
                     return [obj]
             else:
-                return context.document.get_persistence().get_content_nodes(
+                nodes = context.document.get_persistence().get_content_nodes(
                     self.name, obj, context.last_op != "/"
                 )
+                # If first_only is True, return only the first matching node
+                return nodes[:1] if context.first_only else nodes
+
         if isinstance(obj, ContentFeature):
             return self.name == "*" or (
-                obj.feature_type == self.prefix and obj.name == self.name
+                    obj.feature_type == self.prefix and obj.name == self.name
             )
         return False
 

{kodexa-7.0.12396164812 → kodexa-7.0.12397101638}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "kodexa"
-version = "7.0.012396164812"
+version = "7.0.012397101638"
 description = "Python SDK for the Kodexa Platform"
 authors = ["Austin Redenbaugh <austin@kodexa.com>", "Philip Dodds <philip@kodexa.com>", "Romar Cablao <rcablao@kodexa.com>", "Amadea Paula Dodds <amadeapaula@kodexa.com>"]
 readme = "README.md"