implica 0.3.3__py3-none-any.whl → 0.4.0__py3-none-any.whl

implica/__init__.py

@@ -29,6 +29,7 @@ __all__ = [
     "Application",
     "var",
     "app",
+    "type_from_string",
     "Combinator",
     "S",
     "K",
@@ -41,4 +42,4 @@ __all__ = [
     "mutations",
 ]
 
-__version__ = "0.3.3"
+__version__ = "0.4.0"

implica/core/__init__.py

@@ -1,4 +1,14 @@
-from .types import BaseType, Variable, Application, var, app
+from .types import BaseType, Variable, Application, var, app, type_from_string
 from .combinator import Combinator, S, K
 
-__all__ = ["BaseType", "Variable", "Application", "var", "app", "Combinator", "S", "K"]
+__all__ = [
+    "BaseType",
+    "Variable",
+    "Application",
+    "var",
+    "app",
+    "type_from_string",
+    "Combinator",
+    "S",
+    "K",
+]

implica/core/types.py

@@ -178,3 +178,47 @@ def app(input_type: BaseType, output_type: BaseType) -> Application:
         Application: A new Application instance
     """
     return Application(input_type=input_type, output_type=output_type)
+
+
+def type_from_string(type_str: str) -> BaseType:
+    """
+    Parse a string representation of a type into a BaseType instance.
+
+    Supports simple variables (e.g., "A") and implication types (e.g., "A -> B").
+    Handles nested types with parentheses (e.g., "(A -> B) -> C").
+    The arrow operator (->) is right-associative, so "A -> B -> C" is parsed as "A -> (B -> C)".
+
+    Args:
+        type_str: String representation of the type
+
+    Returns:
+        BaseType: The parsed type (Variable or Application)
+
+    Raises:
+        ValueError: If the string cannot be parsed as a valid type
+
+    Examples:
+        >>> type_from_string("A")
+        Variable(name='A')
+        >>> type_from_string("A -> B")
+        Application(input_type=Variable(name='A'), output_type=Variable(name='B'))
+        >>> type_from_string("(A -> B) -> C")
+        Application(input_type=Application(...), output_type=Variable(name='C'))
+    """
+    if not type_str or not type_str.strip():
+        raise ValueError("Type string cannot be empty")
+
+    type_str = type_str.strip()
+
+    # Tokenize the input using the utils module
+    from implica.utils import tokenize, parse_type
+
+    tokens = tokenize(type_str)
+
+    # Parse the tokens into a type using the utils module
+    result, remaining = parse_type(tokens)
+
+    if remaining:
+        raise ValueError(f"Unexpected tokens after parsing: {' '.join(remaining)}")
+
+    return result

implica/utils/__init__.py

@@ -0,0 +1,7 @@
+"""
+Utility functions for the implica package.
+"""
+
+from .parsing import tokenize, parse_type, parse_primary
+
+__all__ = ["tokenize", "parse_type", "parse_primary"]

implica/utils/parsing.py

@@ -0,0 +1,159 @@
+"""
+Utility functions for parsing type strings.
+
+This module contains helper functions for parsing and manipulating types.
+"""
+
+from typing import List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from implica.core.types import BaseType
+
+
+def tokenize(type_str: str) -> List[str]:
+    """
+    Tokenize a type string into a list of tokens.
+
+    Tokens include: variable names, '(', ')', and '->'.
+
+    Args:
+        type_str: The type string to tokenize
+
+    Returns:
+        List[str]: List of tokens
+
+    Raises:
+        ValueError: If invalid characters are found
+    """
+    tokens = []
+    i = 0
+    while i < len(type_str):
+        char = type_str[i]
+
+        # Skip whitespace
+        if char.isspace():
+            i += 1
+            continue
+
+        # Handle parentheses
+        if char in "()":
+            tokens.append(char)
+            i += 1
+            continue
+
+        # Handle arrow operator
+        if char == "-":
+            if i + 1 < len(type_str) and type_str[i + 1] == ">":
+                tokens.append("->")
+                i += 2
+                continue
+            else:
+                raise ValueError(f"Invalid character '-' at position {i}")
+
+        # Handle variable names (alphanumeric and underscores)
+        if char.isalnum() or char == "_":
+            var_name = ""
+            while i < len(type_str) and (type_str[i].isalnum() or type_str[i] == "_"):
+                var_name += type_str[i]
+                i += 1
+            tokens.append(var_name)
+            continue
+
+        # Invalid character
+        raise ValueError(f"Invalid character '{char}' at position {i}")
+
+    return tokens
+
+
+def parse_type(tokens: List[str]) -> tuple["BaseType", List[str]]:
+    """
+    Parse a list of tokens into a type.
+
+    Uses recursive descent parsing with right-associativity for the arrow operator.
+
+    Args:
+        tokens: List of tokens to parse
+
+    Returns:
+        tuple[BaseType, List[str]]: Parsed type and remaining tokens
+
+    Raises:
+        ValueError: If tokens cannot be parsed
+    """
+    from implica.core.types import Application
+
+    if not tokens:
+        raise ValueError("Unexpected end of input")
+
+    # Parse the left-hand side (either a variable or a parenthesized type)
+    left, remaining = parse_primary(tokens)
+
+    # Check if we have an arrow operator
+    if remaining and remaining[0] == "->":
+        # Consume the arrow
+        remaining = remaining[1:]
+
+        # Parse the right-hand side (right-associative)
+        right, remaining = parse_type(remaining)
+
+        # Create application
+        return Application(input_type=left, output_type=right), remaining
+
+    # No arrow, just return the primary type
+    return left, remaining
+
+
+def parse_primary(tokens: List[str]) -> tuple["BaseType", List[str]]:
+    """
+    Parse a primary type (variable or parenthesized type).
+
+    Args:
+        tokens: List of tokens to parse
+
+    Returns:
+        tuple[BaseType, List[str]]: Parsed type and remaining tokens
+
+    Raises:
+        ValueError: If tokens cannot be parsed
+    """
+    from implica.core.types import Variable
+
+    if not tokens:
+        raise ValueError("Unexpected end of input")
+
+    token = tokens[0]
+
+    # Handle parenthesized type
+    if token == "(":
+        # Find matching closing parenthesis
+        depth = 1
+        i = 1
+        while i < len(tokens) and depth > 0:
+            if tokens[i] == "(":
+                depth += 1
+            elif tokens[i] == ")":
+                depth -= 1
+            i += 1
+
+        if depth != 0:
+            raise ValueError("Mismatched parentheses")
+
+        # Parse the content inside parentheses
+        inner_tokens = tokens[1 : i - 1]
+        if not inner_tokens:
+            raise ValueError("Empty parentheses")
+
+        result, inner_remaining = parse_type(inner_tokens)
+
+        if inner_remaining:
+            raise ValueError(
+                f"Unexpected tokens inside parentheses: {' '.join(inner_remaining)}"
+            )
+
+        return result, tokens[i:]
+
+    # Handle variable name
+    if token not in ["->", ")"]:
+        return Variable(name=token), tokens[1:]
+
+    raise ValueError(f"Unexpected token: {token}")

{implica-0.3.3.dist-info → implica-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: implica
-Version: 0.3.3
+Version: 0.4.0
 Summary: A package for working with graphs representing minimal implicational logic models
 Author: Carlos Fernandez
 Author-email: carlos.ferlo@outlook.com
@@ -24,6 +24,7 @@ A Python package for working with graphs representing minimal implicational logi
 ## Features
 
 - 🎯 **Type System**: Build complex type expressions using variables and applications (function types)
+- 🔍 **Variable Extraction**: Recursively extract all variables from any type expression
 - 🧩 **Combinators**: Work with S and K combinators from combinatory logic
 - 📊 **Graph Structure**: Represent type transformations as nodes and edges in a directed graph
 - 🔄 **Transactional Operations**: Safely modify graphs with automatic rollback on failure
@@ -106,6 +107,129 @@ print(complex_function)   # Output: (A -> B) -> C
 print(nested_function)    # Output: A -> B -> C
 ```
 
+#### Parsing Types from Strings
+
+You can also create types by parsing string representations using `type_from_string()`:
+
+```python
+import implica as imp
+
+# Parse simple variables
+A = imp.type_from_string("A")
+print(A)  # Output: A
+
+# Parse function types
+func = imp.type_from_string("A -> B")
+print(func)  # Output: A -> B
+
+# Parse nested types with right-associativity
+nested = imp.type_from_string("A -> B -> C")
+print(nested)  # Output: A -> B -> C
+# This is equivalent to: A -> (B -> C)
+
+# Parse with explicit parentheses
+left_assoc = imp.type_from_string("(A -> B) -> C")
+print(left_assoc)  # Output: (A -> B) -> C
+
+# Parse complex nested types
+complex = imp.type_from_string("((A -> B) -> C) -> (D -> E)")
+print(complex)  # Output: ((A -> B) -> C) -> D -> E
+
+# Multi-character variable names
+person_func = imp.type_from_string("Person -> String")
+print(person_func)  # Output: Person -> String
+
+# Variables with numbers and underscores
+data_type = imp.type_from_string("data_1 -> result_2")
+print(data_type)  # Output: data_1 -> result_2
+
+# Unicode characters are supported
+greek = imp.type_from_string("α -> β -> γ")
+print(greek)  # Output: α -> β -> γ
+```
+
+**Parsing rules:**
+
+- The arrow operator `->` is **right-associative**: `A -> B -> C` is parsed as `A -> (B -> C)`
+- Use parentheses to override associativity: `(A -> B) -> C`
+- Variable names can contain letters, numbers, and underscores
+- Whitespace is ignored: `A->B` and `A -> B` are equivalent
+- Unicode characters in variable names are supported
+
+**Error handling:**
+
+```python
+import implica as imp
+
+# Empty string raises ValueError
+try:
+    imp.type_from_string("")
+except ValueError as e:
+    print(f"Error: {e}")  # Error: Type string cannot be empty
+
+# Mismatched parentheses
+try:
+    imp.type_from_string("(A -> B")
+except ValueError as e:
+    print(f"Error: {e}")  # Error: Mismatched parentheses
+
+# Invalid characters
+try:
+    imp.type_from_string("A @ B")
+except ValueError as e:
+    print(f"Error: {e}")  # Error: Invalid character '@' at position 2
+
+# Missing operand
+try:
+    imp.type_from_string("A ->")
+except ValueError as e:
+    print(f"Error: {e}")  # Error: Unexpected end of input
+```
+
+**Use cases:**
+
+- Parse type expressions from configuration files or user input
+- Create types dynamically from strings
+- Simplify type construction with readable syntax
+- Testing and debugging with human-readable type representations
+
+#### Extracting Variables from Types
+
+Every type has a `variables` property that returns a list of all variables contained in that type. This is computed recursively and may include duplicate variables if they appear multiple times:
+
+```python
+import implica as imp
+
+# Simple variable returns itself
+A = imp.var("A")
+print(A.variables)  # Output: [Variable(name='A')]
+
+# Application returns all variables from both input and output
+B = imp.var("B")
+func = imp.app(A, B)
+print([v.name for v in func.variables])  # Output: ['A', 'B']
+
+# Nested types return all variables recursively
+C = imp.var("C")
+nested = imp.app(imp.app(A, B), C)  # (A -> B) -> C
+print([v.name for v in nested.variables])  # Output: ['A', 'B', 'C']
+
+# Duplicates are included
+same_var = imp.app(A, A)  # A -> A
+print([v.name for v in same_var.variables])  # Output: ['A', 'A']
+
+# Complex example with duplicates
+complex = imp.app(imp.app(A, B), A)  # (A -> B) -> A
+print([v.name for v in complex.variables])  # Output: ['A', 'B', 'A']
+```
+
+**Use cases:**
+
+- Analyze which variables are used in a complex type expression
+- Count occurrences of specific variables in a type
+- Validate that certain variables are present or absent
+- Generate variable lists for quantification or substitution operations
+
 ### Combinators
 
 Combinators represent transformations between types. The library includes the S and K combinators from combinatory logic:
@@ -800,6 +924,249 @@ ensure_graph_state(
 print(f"Final state: {graph.node_count()} nodes")  # Output: 2 (X and Y)
 ```
 
+### Example 10: Analyzing Type Variables
+
+Extract and analyze variables from complex type expressions:
+
+```python
+import implica as imp
+
+# Create a complex type expression
+A = imp.var("A")
+B = imp.var("B")
+C = imp.var("C")
+
+# ((A -> B) -> C) -> (A -> B)
+inner = imp.app(A, B)
+middle = imp.app(inner, C)
+complex_type = imp.app(middle, inner)
+
+print(f"Type: {complex_type}")
+# Output: ((A -> B) -> C) -> A -> B
+
+# Get all variables (including duplicates)
+variables = complex_type.variables
+print(f"All variables: {[v.name for v in variables]}")
+# Output: ['A', 'B', 'C', 'A', 'B']
+
+# Count unique variables
+unique_vars = {v.name for v in variables}
+print(f"Unique variables: {unique_vars}")
+# Output: {'A', 'B', 'C'}
+
+# Count occurrences
+from collections import Counter
+var_counts = Counter(v.name for v in variables)
+print(f"Variable counts: {dict(var_counts)}")
+# Output: {'A': 2, 'B': 2, 'C': 1}
+
+# Check if a specific variable is used
+def uses_variable(type_expr, var_name):
+    """Check if a type expression uses a specific variable."""
+    return any(v.name == var_name for v in type_expr.variables)
+
+print(f"Uses A: {uses_variable(complex_type, 'A')}")  # Output: True
+print(f"Uses D: {uses_variable(complex_type, 'D')}")  # Output: False
+
+# Find all types in a graph that use a specific variable
+graph = imp.Graph()
+
+# Create various types
+types_to_add = [
+    imp.var("X"),
+    imp.var("Y"),
+    imp.app(A, B),
+    imp.app(B, C),
+    imp.app(A, imp.app(B, C)),
+]
+
+with graph.connect() as conn:
+    for t in types_to_add:
+        conn.add_node(imp.node(t))
+
+# Find all nodes containing variable "B"
+nodes_with_B = [
+    n for n in graph.nodes()
+    if any(v.name == "B" for v in n.type.variables)
+]
+
+print(f"\nNodes containing variable B:")
+for n in nodes_with_B:
+    print(f"  - {n.type}")
+# Output:
+#   - A -> B
+#   - B -> C
+#   - A -> B -> C
+
+# Calculate the "complexity" of a type by counting its variables
+def type_complexity(type_expr):
+    """Calculate complexity as the total number of variables."""
+    return len(type_expr.variables)
+
+print(f"\nType complexities:")
+for n in graph.nodes():
+    print(f"  {n.type}: {type_complexity(n.type)}")
+# Output:
+#   X: 1
+#   Y: 1
+#   A -> B: 2
+#   B -> C: 2
+#   A -> B -> C: 3
+```
+
+### Example 11: Using type_from_string for Dynamic Type Creation
+
+Parse types from strings for flexible, dynamic type construction:
+
+```python
+import implica as imp
+
+# Create a graph
+graph = imp.Graph()
+
+# Define type expressions as strings (e.g., from a config file or user input)
+type_strings = [
+    "Person",
+    "String",
+    "Int",
+    "Person -> String",  # Get name
+    "Person -> Int",     # Get age
+    "(Person -> String) -> (Person -> Int) -> Person",  # Complex transformation
+]
+
+# Parse and add all types to the graph
+nodes = []
+for type_str in type_strings:
+    parsed_type = imp.type_from_string(type_str)
+    node = imp.node(parsed_type)
+    nodes.append(node)
+
+with graph.connect() as conn:
+    conn.add_many_nodes(nodes)
+
+print(f"Created graph with {graph.node_count()} nodes from string definitions")
+# Output: Created graph with 6 nodes from string definitions
+
+# You can also build a type library from a configuration
+type_library = {
+    "identity": "A -> A",
+    "const": "A -> B -> A",
+    "compose": "(B -> C) -> (A -> B) -> A -> C",
+    "apply": "(A -> B) -> A -> B",
+}
+
+print("\n=== Type Library ===")
+for name, type_str in type_library.items():
+    parsed = imp.type_from_string(type_str)
+    print(f"{name:10} : {parsed}")
+
+# Output:
+# identity   : A -> A
+# const      : A -> B -> A
+# compose    : (B -> C) -> (A -> B) -> A -> C
+# apply      : (A -> B) -> A -> B
+
+# Validate type strings from user input
+def validate_and_parse_type(user_input: str) -> tuple[bool, str, object]:
+    """
+    Validate and parse a type string from user input.
+    Returns (is_valid, message, parsed_type)
+    """
+    try:
+        parsed = imp.type_from_string(user_input)
+        return True, f"Valid type: {parsed}", parsed
+    except ValueError as e:
+        return False, f"Invalid type: {e}", None
+
+# Test validation
+test_inputs = [
+    "A -> B",
+    "(A -> B) -> C",
+    "A ->",  # Invalid
+    "Person -> (Address -> String)",
+    "A @ B",  # Invalid
+]
+
+print("\n=== Type Validation ===")
+for test in test_inputs:
+    is_valid, message, parsed = validate_and_parse_type(test)
+    status = "✓" if is_valid else "✗"
+    print(f"{status} '{test:30}' : {message}")
+
+# Output:
+# ✓ 'A -> B'                      : Valid type: A -> B
+# ✓ '(A -> B) -> C'               : Valid type: (A -> B) -> C
+# ✗ 'A ->'                        : Invalid type: Unexpected end of input
+# ✓ 'Person -> (Address -> String)' : Valid type: Person -> Address -> String
+# ✗ 'A @ B'                       : Invalid type: Invalid character '@' at position 2
+
+# Build a type inference system
+def infer_result_type(func_type_str: str, input_type_str: str) -> str:
+    """
+    Given a function type and an input type, infer the result type.
+    Returns the result type as a string, or an error message.
+    """
+    try:
+        func_type = imp.type_from_string(func_type_str)
+        input_type = imp.type_from_string(input_type_str)
+
+        # Check if func_type is an application
+        if not isinstance(func_type, imp.Application):
+            return f"Error: {func_type_str} is not a function type"
+
+        # Check if input matches function's input type
+        if func_type.input_type.uid != input_type.uid:
+            return f"Error: Type mismatch. Expected {func_type.input_type}, got {input_type}"
+
+        return str(func_type.output_type)
+    except ValueError as e:
+        return f"Error: {e}"
+
+# Test type inference
+print("\n=== Type Inference ===")
+print(f"Apply 'A -> B' to 'A': {infer_result_type('A -> B', 'A')}")
+# Output: B
+
+print(f"Apply 'Person -> String' to 'Person': {infer_result_type('Person -> String', 'Person')}")
+# Output: String
+
+print(f"Apply 'A -> B -> C' to 'A': {infer_result_type('A -> B -> C', 'A')}")
+# Output: B -> C
+
+print(f"Apply 'A -> B' to 'C': {infer_result_type('A -> B', 'C')}")
+# Output: Error: Type mismatch. Expected A, got C
+
+# Parse types from a domain-specific language
+dsl_program = """
+    define Input
+    define Output
+    define Processor = Input -> Output
+    define Chain = Processor -> Processor -> Processor
+"""
+
+print("\n=== Parsing DSL ===")
+for line in dsl_program.strip().split('\n'):
+    line = line.strip()
+    if line.startswith("define "):
+        parts = line[7:].split(" = ")
+        type_name = parts[0].strip()
+
+        if len(parts) == 1:
+            # Simple type definition
+            print(f"{type_name}: <primitive type>")
+        else:
+            # Complex type definition
+            type_expr = parts[1].strip()
+            parsed = imp.type_from_string(type_expr)
+            print(f"{type_name}: {parsed}")
+
+# Output:
+# Input: <primitive type>
+# Output: <primitive type>
+# Processor: Input -> Output
+# Chain: Processor -> Processor -> Processor
+```
+
 ## API Reference
 
 ### Core Module (`implica.core`)
@@ -808,8 +1175,16 @@ print(f"Final state: {graph.node_count()} nodes")  # Output: 2 (X and Y)
 
 - `var(name: str) -> Variable`: Create a type variable
 - `app(input_type: BaseType, output_type: BaseType) -> Application`: Create a function type
+- `type_from_string(type_str: str) -> BaseType`: Parse a type from a string representation
 - `Variable`: Atomic type variable
+  - `name: str`: The name of the variable
+  - `uid: str`: Unique identifier (SHA256 hash)
+  - `variables: list[Variable]`: Returns `[self]`
 - `Application`: Function application type
+  - `input_type: BaseType`: Input type of the function
+  - `output_type: BaseType`: Output type of the function
+  - `uid: str`: Unique identifier (SHA256 hash)
+  - `variables: list[Variable]`: Returns all variables from input and output types (may include duplicates)
 
 **Combinators:**
 
@@ -875,6 +1250,53 @@ print(f"Final state: {graph.node_count()} nodes")  # Output: 2 (X and Y)
 - `TryRemoveNode(node_uid)`: Remove a node or do nothing if it doesn't exist
 - `TryRemoveEdge(edge_uid)`: Remove an edge or do nothing if it doesn't exist
 
+### Utilities Module (`implica.utils`)
+
+**Parsing Functions:**
+
+- `tokenize(type_str: str) -> list[str]`: Tokenize a type string into tokens
+  - Returns a list of tokens: variable names, `'('`, `')'`, and `'->'`
+  - Raises `ValueError` if invalid characters are found
+- `parse_type(tokens: list[str]) -> tuple[BaseType, list[str]]`: Parse tokens into a type
+  - Uses recursive descent parsing with right-associativity for arrows
+  - Returns the parsed type and any remaining tokens
+  - Raises `ValueError` if tokens cannot be parsed
+- `parse_primary(tokens: list[str]) -> tuple[BaseType, list[str]]`: Parse a primary type
+  - Handles variables and parenthesized types
+  - Returns the parsed type and remaining tokens
+  - Raises `ValueError` if tokens cannot be parsed
+
+**Note:** These functions are primarily used internally by `type_from_string()`, but are exposed for advanced use cases where you need direct control over the parsing process.
+
+**Example:**
+
+```python
+from implica.utils import tokenize, parse_type
+
+# Tokenize a type string
+tokens = tokenize("(A -> B) -> C")
+print(tokens)  # Output: ['(', 'A', '->', 'B', ')', '->', 'C']
+
+# Parse the tokens
+type_result, remaining = parse_type(tokens)
+print(type_result)  # Output: (A -> B) -> C
+print(remaining)    # Output: []
+
+# Custom parsing workflow
+def parse_and_validate(type_str: str) -> bool:
+    """Check if a string is a valid type expression."""
+    try:
+        tokens = tokenize(type_str)
+        result, remaining = parse_type(tokens)
+        return len(remaining) == 0  # Valid if no tokens remain
+    except ValueError:
+        return False
+
+print(parse_and_validate("A -> B"))      # Output: True
+print(parse_and_validate("A ->"))        # Output: False
+print(parse_and_validate("(A -> B) -> C"))  # Output: True
+```
+
 ## Development
 
 ### Setup

{implica-0.3.3.dist-info → implica-0.4.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-implica/__init__.py,sha256=0mZ2GjzddOh36dHFon3fW8RIykgyO5KNwYQ5_9RR-Yc,886
-implica/core/__init__.py,sha256=opdPtga0OU0d8CEf5DL4Xl4AriBaOHdVW4mbwdD2A0Y,191
+implica/__init__.py,sha256=BD-fo6jkUvyETCLqulTeVUHrha0jPyxTPgLIMlvV-zo,910
+implica/core/__init__.py,sha256=gwUoJDHZueECsh_X4KXp_6NX1A_tMNu-wJKXjwstzlU,268
 implica/core/combinator.py,sha256=VOeIj_FRMI7fmuMjjbgRBP-FvExnQ6vOjCD-egt96lI,4324
-implica/core/types.py,sha256=AtzQAY9rJ4lIcjqdVZHLDOO-YXSudez4NOzaw6EPjRc,5230
+implica/core/types.py,sha256=QQZ61JfG9CxaiTzMXfg9jA9NfxuZbG8MnEzhy38w4Pw,6647
 implica/graph/__init__.py,sha256=Lj2bUdPZVgMoIYXF7DeMNuFBl3ftqrkAxhGq-Oj0MoQ,172
 implica/graph/connection.py,sha256=IpyvA_J_BQqhecxN3XoQ00Io7zjwok5PGz2TKia35ZQ,13746
 implica/graph/elements.py,sha256=ag5Gdr-5djGnKOEhoEAm3NpWTmw3gnucq1IEv2xxTB4,6015
@@ -24,7 +24,9 @@ implica/mutations/try_remove_edge.py,sha256=2aeg6f6nR49MViyZk15-ys7I5Xt0a2wXycBI
 implica/mutations/try_remove_many_edges.py,sha256=pgZdqFltMaycNBfdjejYVXQZw3i2K1AJYYcsaKk7n74,1596
 implica/mutations/try_remove_many_nodes.py,sha256=DK_BtKuEh_7zm5bzryOi1BVfmuCiQ-SVA9yIdgN-imE,1817
 implica/mutations/try_remove_node.py,sha256=igTEnGUCd0U2_3Rr5SIOSIs4FZmYi2Y6bLk0Ae64Bsg,1837
-implica-0.3.3.dist-info/LICENSE,sha256=jDn9mmsCvjx_av9marP7DBqjfmK1gsQmgycgBRC2Eck,1073
-implica-0.3.3.dist-info/METADATA,sha256=d6yVeAJq0yVrKVdMcBxgEu8-SUkcpH0f2GnePDPE4sU,25200
-implica-0.3.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-implica-0.3.3.dist-info/RECORD,,
+implica/utils/__init__.py,sha256=zh2OscD5SQ3-YLgsTm3-loTExSuhRRbdZTFFVy3Fxdk,164
+implica/utils/parsing.py,sha256=z7ofQ_tmPaGf3HTOwT1EuANJyIjMpB245mX6URBRHnw,4158
+implica-0.4.0.dist-info/LICENSE,sha256=jDn9mmsCvjx_av9marP7DBqjfmK1gsQmgycgBRC2Eck,1073
+implica-0.4.0.dist-info/METADATA,sha256=ZdKzwDnAJxpbSN_O9r0VMsgHnO6owsqswzghs7alS-o,38241
+implica-0.4.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+implica-0.4.0.dist-info/RECORD,,