pyaltiumlib 0.2__tar.gz → 0.4__tar.gz

{pyaltiumlib-0.2/src/pyaltiumlib.egg-info → pyaltiumlib-0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pyaltiumlib
-Version: 0.2
+Version: 0.4
 Summary: PyAltiumLib is a tool to read Altium Designer library files.
 Home-page: https://github.com/ChrisHoyer/pyAltiumLib.git
 Author: Chris Hoyer

{pyaltiumlib-0.2 → pyaltiumlib-0.4}/src/pyaltiumlib/__init__.py

@@ -7,7 +7,7 @@ AUTHOR_NAME = 'Chris Hoyer'
 AUTHOR_EMAIL = 'info@chrishoyer.de'
 CYEAR = '2024-2025'
 
-__version__ = "0.2"
+__version__ = "0.4"
 __author__ = "Chris Hoyer <info@chrishoyer.de>"
 
 import os
@@ -51,8 +51,3 @@ def read(filepath: str) -> Union[SchLib, PcbLib]:
     else:
         logger.error(f"Invalid file type: {filepath}.")
         raise
-    
-
-
-
-

{pyaltiumlib-0.2 → pyaltiumlib-0.4}/src/pyaltiumlib/base.py

@@ -1,5 +1,6 @@
 from pyaltiumlib.datatypes import ParameterColor
 
+import os
 import olefile
 from typing import List, Optional, Dict, Any
 
@@ -17,45 +18,44 @@ class GenericLibFile:
     :param string filepath: The path to the library file
     
     :raises FileNotFoundError: If file is not a supported file.
-    """
-    
-    LibType = None
-    """
-    `string` that specifies the type of the library.
-    """
-
-    LibHeader = ''
-    """`string` that contains the file path to the library.
-    """
-
-    FilePath = ''
-    """
-    `string` that stores the header information of the library.
-    """
-    
-    ComponentCount = 0
-    """
-    `int` with total number of components in the library.
-    """
-
-    Parts = []
-    """
-    `List[any]` is a collection of components derived from :class:`pyaltiumlib.libcomponent.LibComponent` in their specific class 
-    contained in the library.
-    """    
+    """  
     
     def __init__(self, filepath: str):
-        """
-        Initialize a GenericLibFile object.
-        """
+
         if not olefile.isOleFile( filepath ): 
-            logger.error(f"{filepath} is not a supported file.")
+            logger.error(f"'{filepath}' is not a supported file.")
             raise
             
-        self.LibType = type(self)        
+        self.LibType = type(self) 
+        """
+        `string` that specifies the type of the library.
+        """
+        
+        self.LibHeader = ""
+        """
+        `string` that stores the header information of the library.
+        """
+        
         self.FilePath = filepath 
+        """
+        `string` that contains the file path to the library.
+        """
+        
+        self.FileName = os.path.basename(filepath)
+        """
+        `string` that contains the name of the library.
+        """
+        
         self.ComponentCount = 0
+        """
+        `int` with total number of components in the library.
+        """
+        
         self.Parts = []
+        """
+        `List[any]` is a collection of components derived from :class:`pyaltiumlib.libcomponent.LibComponent` in their specific class 
+        contained in the library.
+        """ 
         
         self._olefile = None
         self._olefile_open = False
@@ -66,19 +66,19 @@ class GenericLibFile:
         self._BackgroundColor = ParameterColor.from_hex("#6D6A69")  
 
 
-    def __repr__(self) -> Dict:
+    def __repr__(self) -> str:
         """
-        Converts public attributes of the high level file to a dictionary.
+        Converts public attributes of the high level file to a string.
 
-        :return: A dict representation of the content of the object
-        :rtype: Dict
+        :return: A string representation of the content of the object
+        :rtype: str
         """
-        return self.read_meta()
+        return str( self.read_meta() )
     
 # =============================================================================
 #     External access 
 # =============================================================================
-
+    
     def read_meta(self) -> Dict:
         """
         Converts public attributes of the high level file to a dictionary.
@@ -92,8 +92,7 @@ class GenericLibFile:
             if not key.startswith("_")
             }
         return public_attributes        
-    
- 
+     
     def list_parts(self) -> List[str]:
         """
         List the names of all parts in the library.
@@ -102,8 +101,7 @@ class GenericLibFile:
         :rtype: List[str]
         """
         return [x.Name for x in self.Parts]
-
-
+   
     def get_part(self, name: str) -> Optional[Any]:
         """
         Get a part of the library by its name.
@@ -128,13 +126,13 @@ class GenericLibFile:
         Open the library file for reading.
         """        
         if self._olefile_open:
-            raise ValueError(f"file: { self.FilePath }. Already open!")
+            raise ValueError(f"file: '{self.FilePath}'. Already open!")
                 
         try:
             self._olefile = olefile.OleFileIO( self.FilePath )
             self._olefile_open = True
         except Exception as e:
-            logger.error(f"Failed to open file: {self.FilePath}. Error: {e}")
+            logger.error(f"Failed to open file: '{self.FilePath}'. Error: {e}")
             raise
 
     def _OpenStream(self, container: str, stream: str) -> Any:
@@ -149,7 +147,7 @@ class GenericLibFile:
             Any: The opened stream.
         """                
         if not self._olefile_open:
-            logger.error(f"file: { self.FilePath }. File not open!")
+            logger.error(f"file: '{self.FilePath}'. File not opened!")
             raise
                     
         if not container == "":

{pyaltiumlib-0.2 → pyaltiumlib-0.4}/src/pyaltiumlib/datatypes/__init__.py

@@ -2,14 +2,15 @@
  
 """
 
-from .parametercollection import ParameterCollection
+
 from .parametercolor import ParameterColor
 from .parameterfont import ParameterFont
 from .binaryreader import BinaryReader
 from .coordinate import Coordinate, CoordinatePoint
+from .parametercollection import ParameterCollection
 
 # Schematic related
-from .schematicpin import SchematicPin
+from .parametercollection import SchematicPin
 from .schematicmapping import (
     SchematicLineWidth, SchematicLineStyle, SchematicLineShape,
     SchematicPinSymbol, SchematicPinElectricalType, SchematicTextOrientation,

pyaltiumlib-0.4/src/pyaltiumlib/datatypes/binaryreader.py

@@ -0,0 +1,193 @@
+from pyaltiumlib.datatypes.coordinate import Coordinate, CoordinatePoint
+
+# Configure logging
+import logging
+logger = logging.getLogger(__name__)
+
+class BinaryReader:
+    """
+    A utility class for reading binary data with structured methods.
+    
+    :param bytes data: The binary data to be read.
+    """    
+    def __init__(self, data):
+        self.data = data
+        self.offset = 0
+
+    @classmethod        
+    def from_stream(cls, stream, size_length=4):
+        """
+        Reads a binary block from a stream and initializes a BinaryReader.
+        
+        :param file-like object stream: The binary stream to read from.
+        :param int optional size_length: Number of bytes indicating the block size.
+        :return: An instance of BinaryReader.
+        :rtype: BinaryReader
+        """
+        length = int.from_bytes( stream.read( size_length ), "little" )
+        data = stream.read( length )
+        
+        if len(data) != length:
+             logger.warning("Stream does not match the declared block length.")        
+        
+        return cls( data )       
+
+    def has_content(self):
+        """
+        Checks if there is remaining data to read.
+        
+        :return: True if data exists, False otherwise.
+        :rtype: bool
+        """
+        return not len(self.data) == 0
+    
+    def length(self):
+        """
+        Returns the length of the binary data.
+        
+        :return: The length of the data.
+        :rtype: int
+        """
+        return len(self.data)
+        
+    def read(self, length):
+        """
+        Reads a specified number of bytes from the binary data.
+        
+        :param int length: The number of bytes to read.
+        :return: The read bytes.
+        :rtype: bytes
+        """                    
+        if self.offset + length > len(self.data):
+            logger.warning("Not enough data to read the requested length.")
+        
+        result = self.data[self.offset:self.offset + length]
+        self.offset += length
+        return result       
+
+    def read_byte(self):
+        """
+        Reads a single byte from the binary data.
+        
+        :return: The read byte.
+        :rtype: bytes
+        """
+        return self.read(1)
+
+    def read_int8(self, signed=False):
+        """
+        Reads an 8-bit integer.
+        
+        :param bool optional signed: Whether to interpret the value as signed.
+        :return: The integer value.
+        :rtype: int
+        """
+        return int.from_bytes(self.read_byte(), signed=signed)
+    
+    def read_int16(self, signed=False):
+        """
+        Reads a 16-bit integer.
+        
+        :param bool optional signed: Whether to interpret the value as signed.
+        :return: The integer value.
+        :rtype: int
+        """
+        return int.from_bytes(self.read(2), byteorder="little", signed=signed)
+    
+    def read_int32(self, signed=False):
+        """
+        Reads a 32-bit integer.
+        
+        :param bool optional signed: Whether to interpret the value as signed.
+        :return: The integer value.
+        :rtype: int
+        """
+        return int.from_bytes(self.read(4), byteorder="little", signed=signed)
+
+    def read_double(self):
+        """
+        Reads an IEEE 754 double-precision floating point value.
+        
+        :return: The double value.
+        :rtype: float
+        """
+        value = int.from_bytes(self.read(8), byteorder='little', signed=False)
+        sign = (value >> 63) & 0x1
+        exponent = (value >> 52) & 0x7FF
+        mantissa = value & ((1 << 52) - 1)
+
+        if exponent == 0x7FF:
+            return float('inf') if mantissa == 0 else float('nan')
+
+        if exponent == 0:
+            result = (mantissa / (1 << 52)) * (2 ** (-1022))
+        else:
+            result = (1 + (mantissa / (1 << 52))) * (2 ** (exponent - 1023))
+
+        return -result if sign == 1 else result
+
+    def read_string_block(self, size_string=1):
+        """
+        Reads a length-prefixed string.
+        
+        :param int optional size_string: Number of bytes specifying the string length.
+        
+        :return: The decoded string.
+        :rtype: str
+        """
+        length_string = int.from_bytes(self.read(size_string), "little")
+        string_data = self.read( length_string )
+                 
+        if len(string_data) != length_string:
+            logger.warning("String does not match the declared string length.")        
+        
+        return string_data.decode('windows-1252')
+
+    def read_bin_coord(self, scaley=-1.0, double=False, double_scaling = 1/10000.0):
+        """
+        Reads a binary coordinate pair and returns a CoordinatePoint.
+        
+        :param float scaley: Scaling factor for the Y coordinate.
+        :param bool optional double: Read coordinates as double
+        :param float optional float: Scaling of double values
+        
+        :return: A CoordinatePoint object.
+        :rtype: CoordinatePoint
+        """
+        if double:
+            x = (self.read_double() * double_scaling)
+            y = (self.read_double() * double_scaling) * scaley
+            return CoordinatePoint( Coordinate(x), Coordinate(y))  
+        
+        else:
+            x = self.read(4)
+            y = self.read(4)
+            return CoordinatePoint( Coordinate.parse_bin(x), Coordinate.parse_bin(y, scale=scaley))  
+
+    def read_unicode_text(self, length=32, encoding='utf-16-le'):
+        """
+        Reads a Unicode string of fixed length.
+        
+        :param int optional length: Maximum length of the string in bytes.
+        :param str optional encoding: The encoding format.
+        
+        :return: The decoded Unicode string.
+        :rtype: str
+        """
+        pos = self.offset
+        data = []
+        while len(data) < length:
+            
+            if self.offset + 2 > len(self.data):
+                logger.warning("Not enough data to read.")
+                
+            unicode_char = self.read(2)
+            if unicode_char == b'\x00\x00':  # Null terminator
+                break
+            data.extend(unicode_char)
+            
+        # Ensure we skip the remaining bytes to read exactly `length` bytes
+        self.offset = pos + length
+        
+        return bytes(data).decode(encoding)
+

{pyaltiumlib-0.2 → pyaltiumlib-0.4}/src/pyaltiumlib/datatypes/coordinate.py

@@ -1,30 +1,64 @@
 import math
 
-# =============================================================================
-#     Single Coordinate
-# =============================================================================   
+# Set up logging
+import logging
+logger = logging.getLogger(__name__)
 
 class Coordinate:
+    """
+    Represents a single coordinate value.
+
+    This class provides parsing functions for extracting coordinates from
+    different data formats, as well as mathematical operations.
+
+    :param value: The numerical value of the coordinate.
+    :type value: int or float
+
+
+    **Operations:**
+    
+    Supports addition, subtraction, multiplication, and division with both
+    integers, floats, and other `Coordinate` instances. Can be compared 
+    using `<`, `>`, `<=`, `>=` with both `Coordinate` instances and numerical values.
+    """
+
     def __init__(self, value):
         self.value = value
-        
+
     @classmethod
-    def parse_dpx(cls, key, data, scale=1.0):        
+    def parse_dpx(cls, key, data, scale=1.0):
+        """
+        Parses a coordinate from a parameter collection data dictionary (schematic file).
+
+        :param str key: The key corresponding to the coordinate.
+        :param dict data: The dictionary containing coordinate data.
+        :param float, optional scale: Scaling factor for the parsed coordinate.
+
+        :return: A Coordinate instance with the parsed value.
+        :rtype: Coordinate
+        """
         num = int(data.get(key, 0))
         frac = int(data.get(key + "_frac", 0))
-        
         coord = (num * 10.0 + frac / 10000.0)
-        
-        return cls( scale * coord / 10 )
- 
+        return cls(scale * coord / 10)
+
     @classmethod
     def parse_bin(cls, x_bytes, scale=1.0):
+        """
+        Parses a coordinate from binary data (pcb file).
+
+        :param bytes x_bytes: Binary representation of the coordinate.
+        :param float, optional scale: Scaling factor for the parsed coordinate.
+
+        :return: A Coordinate instance with the parsed value.
+        :rtype: Coordinate
+        """
         x = int.from_bytes(x_bytes, byteorder="little", signed=True)
-        
-        return cls( scale * x / 10000.0 )
-       
+        return cls(scale * x / 10000.0)
+
     def __repr__(self):
-        return f"{self.value}"       
+        """Returns a string representation of the coordinate."""
+        return f"{self.value}"
 
     def __float__(self):
         return float(self.value)
@@ -33,28 +67,31 @@ class Coordinate:
         return int(self.value)
 
 # ================== Math Functions =========================================
-    
+
     def __abs__(self):
-        return abs( int(self.value) )
+        return abs(int(self.value))
 
     def __truediv__(self, other):
         if isinstance(other, (int, float)):
             if other == 0:
-                raise ZeroDivisionError("Division by zero is not allowed.")
+                logger.warning("Division by zero is not allowed.")
+                raise
             return Coordinate(self.value / other)
+
         elif isinstance(other, Coordinate):
             if other.value == 0:
-                raise ZeroDivisionError("Division by zero is not allowed.")
+                logger.warning("Division by zero is not allowed.")
+                raise
             return Coordinate(self.value / other.value)
         return NotImplemented
-    
+
     def __mul__(self, other):
         if isinstance(other, (int, float)):
             return Coordinate(self.value * other)
         elif isinstance(other, Coordinate):
             return Coordinate(self.value * other.value)
         return NotImplemented
-    
+
     def __add__(self, other):
         if isinstance(other, (int, float)):
             return Coordinate(self.value + other)
@@ -80,7 +117,7 @@ class Coordinate:
     
     def __rsub__(self, other):
         return self.__sub__(other)
-
+    
     def __lt__(self, other):
         if isinstance(other, Coordinate):
             return self.value < other.value
@@ -100,56 +137,98 @@ class Coordinate:
 
     def __ge__(self, other):
         return self > other or self == other
-  
+
+# =============================================================================       
 # =============================================================================
 #     2D Coordinate Point
 # =============================================================================   
 
-class CoordinatePoint:
+class CoordinatePoint: 
+    """    
+    This class encapsulates two `Coordinate` instances for the X and Y axes.
+
+    :param int, float, or Coordinate x: The X-coordinate value.
+    :param int, float, or Coordinate y: The Y-coordinate value.
+
+    **Mathematical Operations:**
+    
+    Supports addition, subtraction, multiplication, and division with
+    `CoordinatePoint` instances or numerical values.
+    """
+
     def __init__(self, x, y):
         if not isinstance(x, Coordinate):
             x = Coordinate(x)
         if not isinstance(y, Coordinate):
             y = Coordinate(y)
-            
         self.x = x
         self.y = y
-        
+
     def __repr__(self):
-        return f"({self.x};{self.y})" 
-    
+        """Returns a string representation of the coordinate point."""
+        return f"({self.x};{self.y})"
+
     def to_int(self):
-        return CoordinatePoint( int(self.x), int(self.y))
+        """Converts the coordinate point to integer values."""
+        return CoordinatePoint(int(self.x), int(self.y))
 
     def to_int_tuple(self):
-        return ( int(self.x), int(self.y))
-    
+        """Returns the coordinate point as a tuple of integers."""
+        return int(self.x), int(self.y)
+
     def expand(self, size):
+        """
+        Expands the coordinate point by a given size.
+
+        :param size: The amount to expand by.
+        :type size: int, float, or Coordinate
+        :return: A new expanded CoordinatePoint.
+        :rtype: CoordinatePoint
+        """
         if isinstance(size, (int, float)):
             return CoordinatePoint(self.x + size, self.y + size)
         if isinstance(size, (int, Coordinate)):
             return CoordinatePoint(self.x + size.value, self.y - size.value)
-        
+
     def rotate(self, center, angle):
-        
-            theta = math.radians(angle)
-            x_rel = self.x - center.x
-            y_rel = self.y - center.y
-    
-            x_rot = x_rel * math.cos(theta) - y_rel * math.sin(theta)
-            y_rot = x_rel * math.sin(theta) + y_rel * math.cos(theta)
-    
-            self.x = x_rot + center.x
-            self.y = y_rot + center.y
-            return self
+        """
+        Rotates the coordinate point around a given center by an angle.
+
+        :param center: The center point for rotation.
+        :type center: CoordinatePoint
+        :param angle: The rotation angle in degrees.
+        :type angle: float
+        :return: The rotated CoordinatePoint.
+        :rtype: CoordinatePoint
+        """
+        theta = math.radians(angle)
+        x_rel = self.x - center.x
+        y_rel = self.y - center.y
+
+        x_rot = x_rel * math.cos(theta) - y_rel * math.sin(theta)
+        y_rot = x_rel * math.sin(theta) + y_rel * math.cos(theta)
+
+        self.x = x_rot + center.x
+        self.y = y_rot + center.y
+        return self
 
     def offset(self, offset_x, offset_y):
-        
-            self.x = self.x + offset_x
-            self.y = self.y + offset_y
-            return self
-    
+        """
+        Offsets the coordinate point by given values.
+
+        :param offset_x: Offset for the X coordinate.
+        :type offset_x: int or float
+        :param offset_y: Offset for the Y coordinate.
+        :type offset_y: int or float
+        :return: The offset CoordinatePoint.
+        :rtype: CoordinatePoint
+        """
+        self.x = self.x + offset_x
+        self.y = self.y + offset_y
+        return self
+
     def copy(self):
+        """Returns a copy of the CoordinatePoint."""
         return CoordinatePoint(self.x, self.y)
 
 # ================== Math Functions =========================================
@@ -171,11 +250,13 @@ class CoordinatePoint:
     def __truediv__(self, other):
         if isinstance(other, (int, float)):
             if other == 0:
-                raise ZeroDivisionError("Division by zero is not allowed.")
+                logger.warning("Division by zero is not allowed.")
+                raise
             return CoordinatePoint(self.x / other, self.y / other)
         elif isinstance(other, Coordinate):
             if other.value == 0:
-                raise ZeroDivisionError("Division by zero is not allowed.")
+                logger.warning("Division by zero is not allowed.")
+                raise
             return  CoordinatePoint(self.x / other.x, self.y / other.y)
         return NotImplemented
     
@@ -193,5 +274,4 @@ class CoordinatePoint:
         return self.__add__(other)
     
     def __rsub__(self, other):
-        return self.__sub__(other)
-
+        return self.__sub__(other)