snapmark 2.0.0__py3-none-any.whl

snapmark/__init__.py

@@ -0,0 +1,165 @@
+"""
+SnapMark - Library for marking and manipulating DXF files.
+
+Basic Usage:
+    import snapmark as sm
+    
+    # Quick mark by file name
+    sm.mark_by_name("Examples/Input")
+    
+    # Mark folder
+    sm.Operation.process_folder("folder", mark)
+    
+    # Multiple pipeline example
+    manager = sm.IterationManager("folder")
+    manager.add_operation(
+        sm.Aligner(),
+        sm.AddMark(sequence),
+        sm.CountHoles(sm.find_circle_by_radius(5, 10))
+    )
+    manager.execute()
+"""
+
+# ========== CORE: Main operations ==========
+from .operations.basic_operations import (
+    Operation,
+    AddMark,
+    SubstituteCircle,
+    AddX,
+    RemoveCircle,
+    RemoveLayer,
+    PrintLayers,
+)
+
+from .operations.counter import (
+    Counter,
+    CountFiles,
+    CountHoles,
+)
+
+from .operations.aligner import Aligner
+
+# ========== SEQUENCE (NEW SYSTEM) ==========
+from .sequence.sequence_system import (
+    SequenceBuilder,
+    from_file_name,
+    from_splitted_text
+)
+
+# ========== SEQUENCE (OLD - DEPRECATED) ==========
+from .sequence.sequence_legacy import (
+    Conc,
+    FixSeq,
+)
+
+# ========== SHORTCUTS ========== 
+from .shortcuts import (
+    mark_by_name,
+    mark_by_splitted_text,
+    mark_with_sequence,
+    quick_count_holes,
+    single_file_pipeline,  
+    restore_backup
+)
+
+
+# ========== ITERATION MANAGER ==========
+from .core import IterationManager, iteration_manager  # iteration_manager = alias legacy
+
+# ========== UTILITIES ==========
+from .utils.backup_manager import BackupManager
+from .utils.helpers import (
+    count_holes,
+    find_all_circles,
+    find_circle_by_radius,
+)
+
+# ========== CHECKING/SEARCH ==========
+from .checking.checking import (
+    find_spec_holes,
+    find_circle_centers,
+    find_longer_entity,
+    print_layers as print_document_layers,
+    print_entities,
+)
+
+
+# ========== METADATA ==========
+__version__ = "2.0.0"
+__author__ = "serg_you_lin"
+__all__ = [
+    # Shortcuts (main API)
+    'mark_by_name',
+    'mark_by_splitted_text',
+    'mark_with_sequence',
+    'quick_count_holes',
+    'single_file_pipeline',
+    'restore_backup',
+    
+    # Sequence Builder
+    'SequenceBuilder',
+    'from_file_name',
+    'from_file_part',
+
+    # Operations
+    'Operation',
+    'AddMark',
+    'AddCircle',
+    'SubstituteCircle',
+    'AddX',
+    'RemoveCircle',
+    'RemoveLayer',
+    'PrintLayers',
+    'Counter',
+    'CountFiles',
+    'CountHoles',
+    'Aligner',
+    
+    # Manager
+    'IterationManager',
+    'iteration_manager',  # Alias legacy
+    
+    # Utils
+    'BackupManager',
+    'count_holes',
+    'mult_campana',
+    'find_all_circles',
+    'find_circle_by_radius',
+    
+    # Checking
+    'find_spec_holes',
+    'find_circle_centers',
+    'find_longer_entity',
+    'print_document_layers',
+    'print_entities',
+
+    # DEPRECATED (manteinence to backward compatibility)
+    'Conc',
+    'FixSeq',
+]
+
+
+
+# ========== DEPRECATION WARNINGS ==========
+
+def __getattr__(name):
+    """
+    Manages import of deprecated functions with warning.
+    """
+    import warnings
+    
+    deprecated = {
+        'select_files': 'Use file_pattern in process_folder() instead',
+        'iter_on_a_folder': 'Use Operation.process_folder() or IterationManager',
+    }
+    
+    if name in deprecated:
+        warnings.warn(
+            f"{name} is deprecated. {deprecated[name]}",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        # Per ora solleva errore (funzioni rimosse)
+        raise AttributeError(f"Deprecated removed function: {name}")
+    
+    raise AttributeError(f"module 'snapmark' has no attribute '{name}'")

snapmark/checking/checking.py

@@ -0,0 +1,183 @@
+import sys
+import os
+import ezdxf
+from snapmark.mark_algorithm.mark_algorithm import *
+from snapmark.entities.add_entities import *
+
+
+# Print the names of the layers
+def print_layers(doc):
+    # print("Layers:")
+    for layer in doc.layers:
+        print(layer.dxf.name)
+        return print(layer.dxf.name)
+    
+def find_spec_holes(doc, diametro_minimo=0, diametro_massimo=float('inf')):
+    """
+    Searches for specific holes in a document based on diameter range.
+    
+    Args:
+        doc: The document containing the entities to search.
+        diametro_minimo: Minimum diameter of the holes to find (default: 0).
+        diametro_massimo: Maximum diameter of the holes to find (default: infinity).
+    
+    Returns:
+        A list of circular entities that match the specified diameter range.
+    """
+    holes = []  # List to store circular entities
+
+    msp = doc.modelspace()  # Access the model space of the drawing
+
+    # Iterate through all entities in the model space
+    for entity in msp.query('CIRCLE'):  # Filter only entities of type circle
+        diameter = entity.dxf.radius * 2  # Calculate the diameter of the circle
+        if diametro_minimo <= diameter <= diametro_massimo:
+            holes.append(entity)
+            # Add the circular entity to the list if it falls within the diameter range
+        
+    return holes
+
+# # Cerca fori specifici
+# def find_spec_holes(doc, diametro_minimo=0, diametro_massimo=float('inf')):
+#     holes = []  # Lista per memorizzare le entità circolari
+
+#     msp = doc.modelspace()  # Accedi al modello spaziale del disegno
+
+#     # Itera attraverso tutte le entità nel modello spaziale
+#     for entity in msp.query('CIRCLE'):  # Filtra solo le entità di tipo cerchio
+#         diametro = entity.dxf.radius * 2  # Calcola il diametro del cerchio
+#         if diametro_minimo <= diametro <= diametro_massimo:
+#             holes.append(entity)
+#             # print(entity)# Aggiungi l'entità circolare alla lista se rientra nel range di diametri
+        
+#     return holes
+
+def find_entities(file_path, entity_type):
+    """Return a list of DXF entities of the given type from the specified file."""
+    # Load DXF file using ezdxf
+    doc = ezdxf.readfile(file_path)
+    
+    # extract entities from model
+    msp = doc.modelspace()
+
+    entities = []
+
+    # Iterate through all entities of the specified type
+    for entity in msp.query(entity_type):
+        entities.append(entity)
+
+    return entities
+
+def print_entities(msp):
+    for e in msp.query():
+        print(e)
+
+
+
+# def find_longer_entity(entities):
+
+#     lato_piu_lungo = None
+#     lunghezza_lato_piu_lungo = 0
+#     lato_piu_lungo_is_sotto = True
+#     minimum_point = float('inf')
+#     # Itera tutte le linee nel modello
+#     for entity in entities:
+#         minimum_point = min(entity.dxf.start.y, entity.dxf.end.y, minimum_point)      
+#         # Calcola la lunghezza della linea utilizzando il teorema di Pitagora
+#         lunghezza = ((entity.dxf.start.x - entity.dxf.end.x) ** 2 + (entity.dxf.start.y - entity.dxf.end.y) ** 2) ** 0.5
+#         # Se la lunghezza della linea è maggiore della lunghezza massima finora trovata, aggiornala
+#         if lunghezza > lunghezza_lato_piu_lungo:
+#             lunghezza_lato_piu_lungo = lunghezza
+#             lato_piu_lungo = entity
+    
+#     # Controllare che il lato più lungo sia una linea perimetrale
+#     if min(lato_piu_lungo.dxf.start.y, lato_piu_lungo.dxf.end.y) > minimum_point:
+#         lato_piu_lungo_is_sotto = False
+    
+#     return lato_piu_lungo, lato_piu_lungo_is_sotto
+
+
+def find_longer_entity(entities):
+    """
+    Finds the longest entity among the given entities and checks if it is below a certain minimum point.
+    
+    Args:
+        entities: A list of entities to evaluate.
+    
+    Returns:
+        A tuple containing the longest entity and a boolean indicating if it is below the minimum point.
+    """
+    
+    longest_side = None
+    longest_side_length = 0
+    longest_side_is_below = True
+    minimum_point = float('inf')
+    
+    # Iterate through all the lines in the model
+    for entity in entities:
+        minimum_point = min(entity.dxf.start.y, entity.dxf.end.y, minimum_point)      
+        # Calculate the length of the line using the Pythagorean theorem
+        length = ((entity.dxf.start.x - entity.dxf.end.x) ** 2 + (entity.dxf.start.y - entity.dxf.end.y) ** 2) ** 0.5
+        # If the length of the line is greater than the maximum length found so far, update it
+        if length > longest_side_length:
+            longest_side_length = length
+            longest_side = entity
+    
+    # Check if the longest side is a perimeter line
+    if min(longest_side.dxf.start.y, longest_side.dxf.end.y) > minimum_point:
+        longest_side_is_below = False
+    
+    return longest_side, longest_side_is_below
+
+
+
+def find_circle_centers(holes_list):
+    """
+    Finds the centers of circles from a list of holes.
+    
+    Args:
+        holes_list: A list of circular entities representing holes.
+    
+    Returns:
+        A list of tuples containing the (x, y) coordinates of the circle centers.
+    """
+    centers = []  # List to store the centers of the circles
+
+    # Iterate through the circular entities in the holes_list
+    for circle in holes_list:  # Use the list passed as an argument
+        center_x = circle.dxf.center.x  # Extract the x coordinate of the circle's center
+        center_y = circle.dxf.center.y  # Extract the y coordinate of the circle's center
+        centers.append((center_x, center_y))  # Add the x and y coordinates of the center to the list
+        
+    return centers
+
+
+def find_circle_centers_2(doc):
+    """
+    Searches for circles in a document and detects their centers.
+    
+    Args:
+        doc: The document containing the entities to search.
+    
+    Returns:
+        A list of tuples containing the (x, y) coordinates of the circle centers.
+    """
+    centers = []  # List to store the centers of the circles
+
+    msp = doc.modelspace()  # Access the model space of the drawing
+
+    # Iterate through all entities in the model space
+    for circle in msp.query('CIRCLE'):  # Filter only entities of type circle
+        center_x = circle.dxf.center.x  # Extract the x coordinate of the circle's center
+        center_y = circle.dxf.center.y  # Extract the y coordinate of the circle's center
+        centers.append((center_x, center_y))  # Add the x and y coordinates of the center to the list
+        
+    return centers
+
+
+def change_layer(entities, new_layer):
+    for entity in entities:
+        entity.set_dxf_attrib('layer', new_layer)
+
+
+

snapmark/core.py

@@ -0,0 +1,154 @@
+"""
+core.py - Core components of SnapMark.
+
+Contains IterationManager for multiple batch operations.
+"""
+import os
+import ezdxf
+from pathlib import Path
+from snapmark.utils.helpers import find_dxf_files
+
+try:
+    from .utils.backup_manager import BackupManager
+    BACKUP_AVAILABLE = True
+except ImportError:
+    BACKUP_AVAILABLE = False
+
+
+class IterationManager:
+    """
+    Manages applying multiple operations in sequence on DXF files.
+    
+    Example:
+        >>> manager = IterationManager("folder_path")
+        >>> manager.add_operation(AddMark(...), CountHoles(...))
+        >>> manager.execute()
+    """
+    
+    def __init__(self, folder_path, use_backup_system=True):
+        """
+        Initializes the IterationManager with the specified folder path and backup option.
+
+        Args:
+            folder_path (str): The path of the folder containing the DXF files.
+            use_backup_system (bool): If True, uses .bak for backups (recommended).
+        """
+
+        self.folder_path = folder_path
+        self.operation_list = []
+        self.use_backup_system = use_backup_system and BACKUP_AVAILABLE
+        
+        if use_backup_system and not BACKUP_AVAILABLE:
+            print("⚠ BackupManager not available")
+    
+    def add_operation(self, *operations):
+        """Adds operations to the pipeline."""
+        for op in operations:
+            self.operation_list.append(op)
+    
+    def execute(self, file_pattern="*.dxf", recursive=False):
+        """
+        Executes all operations on the files in the specified folder.
+        
+        Args:
+            file_pattern (str): Pattern to filter files (e.g., "F*.dxf").
+            recursive (bool): If True, includes subfolders.
+        
+        Returns:
+            dict: Statistics containing {'processed': int, 'modified': int, 'errors': list}.
+        """
+
+        if not self.operation_list:
+            print("⚠ No operations added")
+            return {'processed': 0, 'modified': 0, 'errors': []}
+        
+        dxf_files = find_dxf_files(self.folder_path, recursive)
+
+        if self.use_backup_system:
+            print("🔧 Backup mode active")
+        
+        # Processa file
+        stats = {'processed': 0, 'modified': 0, 'errors': []}
+        
+        for file_path in dxf_files:
+            try:
+                modified = self._process_single_file(str(file_path))
+                stats['processed'] += 1
+                if modified:
+                    stats['modified'] += 1
+            except Exception as e:
+                error_msg = f"Error on {file_path.name}: {str(e)}"
+                stats['errors'].append(error_msg)
+                print(f"❌ {error_msg}")
+        
+        # Final messages
+        self._final_messages()
+        
+        # Report
+        print(f"\n✓ Processed: {stats['processed']}")
+        print(f"✓ Modified: {stats['modified']}")
+        if stats['errors']:
+            print(f"❌ Errors: {len(stats['errors'])}")
+        
+        return stats
+    
+    def _process_single_file(self, file_path: str) -> bool:
+        """Applies operations to a single file."""
+        
+        # Backup
+        if self.use_backup_system:
+            BackupManager.ensure_original(file_path)
+        
+        # Extract folder and filename
+        folder = os.path.dirname(file_path)
+        file_name = os.path.basename(file_path)
+        
+        # Open file
+        doc = ezdxf.readfile(file_path)
+        
+        # Apply operations
+        should_save = False
+        for operation in self.operation_list:
+            temp_should_save = operation.execute(doc, folder, file_name)
+            should_save = should_save or temp_should_save
+            operation.message(file_name)
+        
+        # Save if necessary
+        if should_save:
+            doc.saveas(file_path)
+            return True
+        
+        return False
+    
+    def _final_messages(self):
+        """Prints final messages (e.g., from Counter)."""
+        
+        try:
+            from .operations.counter import Counter
+            for operation in self.operation_list:
+                if isinstance(operation, Counter):
+                    operation.count_message()
+        except ImportError:
+            pass
+    
+    def file_selection_logic(self, filter_files=None):
+        """DEPRECATED: Use execute() instead."""
+        import warnings
+        warnings.warn(
+            "file_selection_logic() is deprecated. Use execute().",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        
+        pattern = "*.dxf"
+        if filter_files:
+            if isinstance(filter_files, str):
+                pattern = filter_files
+            elif isinstance(filter_files, list) and filter_files:
+                pattern = filter_files[0]
+        
+        return self.execute(file_pattern=pattern, recursive=False)
+
+
+# Alias for backward compatibility with old scripts
+iteration_manager = IterationManager

snapmark/entities/add_entities.py

@@ -0,0 +1,120 @@
+
+
+def add_circle(doc, hole_list, radius, layer='0'):
+    """Adds circles at specified positions in the document."""
+    msp = doc.modelspace()  # Access the model space of the drawing
+    for center_x, center_y in hole_list:
+        center = (center_x, center_y)
+        # print(center_x, center_y)
+        msp.add_circle(center=center, radius=radius, dxfattribs={'layer': layer}) 
+
+
+def add_circle_with_handle(doc, center_x, center_y, radius=10, layer='0', handle=68):
+    """Adds a circle at a specified position with a specific handle."""
+    msp = doc.modelspace()  # Access the model space of the drawing
+    center = center_x, center_y
+    
+    # Create a new circle with the specified handle
+    circle = msp.add_circle(center=center, radius=radius, dxfattribs={'layer': layer})
+    circle.dxf.handle = handle  # Set the specified handle
+    
+    return circle
+
+
+def add_x(doc, hole_list, x_size=8, layer='0'):
+    """Adds an 'X' shape at specified positions in the document."""
+    msp = doc.modelspace()
+    for center_x, center_y in hole_list:
+        # Calculate the coordinates for the 'x'
+        x1 = center_x - (x_size / 1.4141) /2
+        y1 = center_y - (x_size / 1.4141) /2
+        x2 = center_x + (x_size / 1.4141) /2
+        y2 = center_y + (x_size / 1.4141) /2
+        
+        # Add diagonal lines to form an 'x'
+        msp.add_line(start=(x1, y1), end=(x2, y2), dxfattribs={'layer': layer})
+        msp.add_line(start=(x1, y2), end=(x2, y1), dxfattribs={'layer': layer})
+
+
+
+def add_numbers_to_layer(doc, sequence, layer = '0'):
+    """Adds a sequence of lines to a specified layer in the document."""
+    msp = doc.modelspace()
+   
+    for scaled_segments, position in sequence.sequence:        
+
+        # Add lines based on the segments at the scaled position
+        scaled_position = position  # The position has already been scaled
+        for i in range(len(scaled_segments) - 1):
+            start_point = (
+                scaled_segments[i][0] + scaled_position[0],
+                scaled_segments[i][1] + scaled_position[1]
+            )
+            end_point = (
+                scaled_segments[i + 1][0] + scaled_position[0],
+                scaled_segments[i + 1][1] + scaled_position[1]
+            )
+
+            msp.add_line(start=start_point, end=end_point, dxfattribs={'layer': layer})
+    
+       
+    
+def delete_circle(doc, hole_list):
+    """Deletes circles from the model based on the provided list."""
+    msp = doc.modelspace()
+    
+    for hole in hole_list:
+        msp.delete_entity(hole)
+
+
+def delete_layer(doc, layer_name):
+    """Deletes a specific layer and all entities associated with."""
+    msp = doc.modelspace()
+
+    # Find all entities belonging to the specified layer
+    entities_to_remove = [entity for entity in msp.query('*[layer=="{}"]'.format(layer_name))]
+
+    # Delete all entities associated with the layer
+    for entity in entities_to_remove:
+        msp.delete_entity(entity)
+
+    # Delete the layer
+    doc.layers.remove(layer_name)
+
+
+            
+def copy_entities_but_2(source_msp, dest_msp, holes_to_exclude=[]):
+    """Copies entities from source model space to target, excluding specified entities."""
+
+    for entity in source_msp.query('*'):
+        if entity not in holes_to_exclude:
+            dest_msp.add_entity(entity)
+            
+            
+
+def copy_entities_but(source_msp, target_msp, entities_to_exclude=[]):
+    """Copies entities from source model space to target, excluding specified entities."""
+    for entity in source_msp.query('*'):
+        exclude = False
+        for exclude_entity in entities_to_exclude:
+            if entity.dxf.handle == exclude_entity.dxf.handle:
+                exclude = True
+                break
+        if not exclude:
+            target_msp.add_entity(entity.clone())
+
+def remove_entities(msp, entities_to_remove):
+    """Removes specified entities from the model space."""
+    # Create a new list of entities excluding those to remove
+    new_entities = [entity for entity in msp.query('*') if entity not in entities_to_remove]
+    
+    # Delete all entities from the model space
+    msp.delete_all_entities()
+    
+    # Add the new entities to the model space
+    for entity in new_entities:
+        msp.add_entity(entity.clone())
+
+
+
+