pyaltiumlib 0.1.0__py3-none-any.whl

pyaltiumlib/__init__.py

@@ -0,0 +1,58 @@
+"""
+pyAltiumLib is a reader and renderer for Altium Library files
+implemented in Python.
+"""
+
+AUTHOR_NAME = 'Chris Hoyer'
+AUTHOR_EMAIL = 'info@chrishoyer.de'
+CYEAR = '2024-2025'
+
+__version__ = "0.1.0"
+__author__ = "Chris Hoyer <info@chrishoyer.de>"
+
+import os
+from typing import Union
+from pyaltiumlib.schlib.lib import SchLib
+from pyaltiumlib.pcblib.lib import PcbLib
+
+# Set up logging
+import logging
+logger = logging.getLogger(__name__)
+
+@staticmethod
+def read(filepath: str) -> Union[SchLib, PcbLib]:
+    """
+    Reads an Altium library file and returns the corresponding library object.
+
+    This method determines whether the given file is a schematic library (`.SchLib`) 
+    or a PCB library (`.PcbLib`) and returns the appropriate class instance.
+
+    :param filepath: The path to the Altium library file.
+    :type filepath: str
+
+    :return: An instance of either :class:`SchLib` or :class:`PcbLib`, 
+             depending on the file type.
+    :rtype: :class:`pyaltiumlib.schlib.lib.SchLib` or :class:`pyaltiumlib.pcblib.lib.PcbLib`
+
+    :raises FileNotFoundError: If the specified file does not exist.
+    :raises ValueError: If the file type is not recognized as `.SchLib` or `.PcbLib`.
+    """
+    if not os.path.isfile( filepath ): 
+        logger.error(f"{filepath} does not exist.")
+        raise
+
+    # Choose the correct class        
+    if filepath.lower().endswith('.schlib'):
+        return SchLib( filepath ) 
+    
+    elif filepath.lower().endswith('.pcblib'):
+        return PcbLib( filepath ) 
+        
+    else:
+        logger.error(f"Invalid file type: {filepath}.")
+        raise
+    
+
+
+
+

pyaltiumlib/base.py

@@ -0,0 +1,172 @@
+from pyaltiumlib.datatypes import ParameterColor
+
+import olefile
+from typing import List, Optional, Dict, Any
+
+# Set up logging
+import logging
+logger = logging.getLogger(__name__)
+
+class GenericLibFile:
+    """
+    Base class for handling Altium Designer library files.
+
+    This class provides fundamental functionality for reading library files
+    in Altium Designer format.
+    
+    :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.")
+            raise
+            
+        self.LibType = type(self)        
+        self.FilePath = filepath    
+        
+        self._olefile = None
+        self._olefile_open = False
+         
+        # extracted file content
+        self._FileHeader = None
+        
+        self._BackgroundColor = ParameterColor.from_hex("#6D6A69")  
+
+
+    def __repr__(self) -> Dict:
+        """
+        Converts public attributes of the high level file to a dictionary.
+
+        :return: A dict representation of the content of the object
+        :rtype: Dict
+        """
+        return self.read_meta()
+    
+# =============================================================================
+#     External access 
+# =============================================================================
+
+    def read_meta(self) -> Dict:
+        """
+        Converts public attributes of the high level file to a dictionary.
+
+        :return: A dict representation of the content of the object
+        :rtype: Dict
+        """
+        public_attributes = {
+            key: value if isinstance(value, str) else str(value)
+            for key, value in self.__dict__.items()
+            if not key.startswith("_")
+            }
+        return public_attributes        
+    
+ 
+    def list_parts(self) -> List[str]:
+        """
+        List the names of all parts in the library.
+
+        :return: A list of part names
+        :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.
+        
+        :param string name: The name of the part.
+
+        :return: The part class derived from :class:`pyaltiumlib.libcomponent.LibComponent` if found, otherwise None.
+        :rtype: Optional[Any]
+        """
+        for part in self.Parts:
+            if part.Name == name:
+                return part
+        return None
+    
+
+# =============================================================================
+#     Internal file handling related functions
+# =============================================================================
+
+    def _OpenFile(self) -> None:
+        """
+        Open the library file for reading.
+        """        
+        if self._olefile_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}")
+            raise
+
+    def _OpenStream(self, container: str, stream: str) -> Any:
+        """
+        Open a stream within the library file.
+
+        Args:
+            container (str): The container name.
+            stream (str): The stream name.
+
+        Returns:
+            Any: The opened stream.
+        """                
+        if not self._olefile_open:
+            logger.error(f"file: { self.FilePath }. File not open!")
+            raise
+                    
+        if not container == "":
+
+            illegal_characters = '<>:"/\\|?*\x00'
+            container = "".join("_" if char in illegal_characters else char for char in container)
+            
+            if not self._olefile.exists( container ):
+                logger.error(f"Part '{container}' does not exist in file '{self.FilePath}'!")
+                raise
+        
+        return self._olefile.openstream( f"{container}/{stream}" if container else stream )
+
+
+    def _CloseFile(self) -> None:
+        """
+        Close the library file.
+        """
+        if hasattr(self, '_olefile') and self._olefile is not None:
+            self._olefile.close()
+            self._olefile_open = False
+

pyaltiumlib/datatypes/__init__.py

@@ -0,0 +1,48 @@
+"""
+ 
+"""
+
+from .parametercollection import ParameterCollection
+from .parametercolor import ParameterColor
+from .parameterfont import ParameterFont
+from .binaryreader import BinaryReader
+from .coordinate import Coordinate, CoordinatePoint
+
+# Schematic related
+from .schematicpin import SchematicPin
+from .schematicmapping import (
+    SchematicLineWidth, SchematicLineStyle, SchematicLineShape,
+    SchematicPinSymbol, SchematicPinElectricalType, SchematicTextOrientation,
+    SchematicTextJustification
+    )
+
+# PCB related
+from .pcblayerdefinition import PCBLayerDefinition
+from .pcbmapping import ( PCBPadShape, PCBHoleShape, PCBStackMode, 
+                         PCBTextJustification, PCBStrokeFont, PCBTextKind
+                         )
+
+
+__all__ = [
+    "ParameterCollection",
+    "ParameterColor",
+    "ParameterFont",
+    "BinaryReader",
+    "Coordinate",
+    "CoordinatePoint",
+    "SchematicPin",
+    "SchematicLineWidth",
+    "SchematicLineStyle",
+    "SchematicLineShape",
+    "SchematicPinSymbol",
+    "SchematicPinElectricalType",
+    "SchematicTextOrientation",
+    "SchematicTextJustification",
+    "PCBLayerDefinition",
+    "PCBPadShape",
+    "PCBStackMode",
+    "PCBHoleShape",
+    "PCBTextJustification",
+    "PCBStrokeFont",
+    "PCBTextKind"
+]

pyaltiumlib/datatypes/binaryreader.py

@@ -0,0 +1,125 @@
+from pyaltiumlib.datatypes.coordinate import Coordinate, CoordinatePoint
+
+class BinaryReader:
+    
+    def __init__(self, data):
+        self.data = data
+        self.offset = 0
+
+    @classmethod        
+    def from_stream(cls, stream, size_length=4):
+        length = int.from_bytes( stream.read( size_length ), "little" )
+        data = stream.read( length )
+        
+        if len(data) != length:
+            raise ValueError("Stream does not match the declared block length.")        
+        
+        return cls( data )       
+
+    def has_content(self):
+        return not len(self.data) == 0
+    
+    def length(self):
+        return len(self.data)
+        
+    def read(self, length):
+                    
+        if self.offset + length > len(self.data):
+            raise ValueError("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):
+        if self.offset + 1 > len(self.data):
+            raise ValueError("Not enough data to read.")
+        return self.read(1)
+
+    def read_int8(self, signed=False):
+        return int.from_bytes(self.read_byte(), signed=signed)
+    
+    def read_int16(self, signed=False):
+        if self.offset + 2 > len(self.data):
+            raise ValueError("Not enough data to read an Int16.")
+        
+        value = int.from_bytes(self.data[self.offset:self.offset + 2], byteorder="little", signed=signed)
+        self.offset += 2
+        return value
+    
+    def read_int32(self, signed=False):
+        if self.offset + 4 > len(self.data):
+            raise ValueError("Not enough data to read an Int32.")
+        
+        value = int.from_bytes(self.data[self.offset:self.offset + 4], byteorder="little", signed=signed)
+        self.offset += 4
+        return value
+
+    def read_double(self):
+        if self.offset + 8 > len(self.data):
+            raise ValueError("Not enough data to read a Double.")
+
+        raw_bytes = self.data[self.offset:self.offset + 8]
+        self.offset += 8
+        return self._decode_double(raw_bytes)
+
+    def read_string_block(self, size_string=1):
+        
+        length_string = int.from_bytes( self.read( size_string ), "little" )
+        string_data = self.read( length_string )
+                 
+        if len(string_data) != length_string:
+            raise ValueError("String does not match the declared string length.")        
+        
+        return string_data.decode('windows-1252')
+
+    def read_bin_coord(self, scaley=-1.0):
+        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'):
+        
+        pos = self.offset
+        data = []
+    
+        while len(data) < length:
+            if self.offset + 2 > len(self.data):
+                raise ValueError("Not enough data to read.")
+            
+            # Read 2 bytes (1 Unicode character)
+            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)
+    
+    
+# =================================0
+
+    def _decode_double(self, raw_bytes):
+        # Decode IEEE 754 double-precision format
+        value = 0
+        for i, b in enumerate(raw_bytes):
+            value |= b << (i * 8)
+
+        sign = (value >> 63) & 0x1
+        exponent = (value >> 52) & 0x7FF
+        mantissa = value & ((1 << 52) - 1)
+
+        if exponent == 0x7FF:
+            if mantissa == 0:
+                return float('inf') if sign == 0 else float('-inf')
+            return 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
+

pyaltiumlib/datatypes/coordinate.py

@@ -0,0 +1,197 @@
+import math
+
+# =============================================================================
+#     Single Coordinate
+# =============================================================================   
+
+class Coordinate:
+    def __init__(self, value):
+        self.value = value
+        
+    @classmethod
+    def parse_dpx(cls, key, data, scale=1.0):        
+        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 )
+ 
+    @classmethod
+    def parse_bin(cls, x_bytes, scale=1.0):
+        x = int.from_bytes(x_bytes, byteorder="little", signed=True)
+        
+        return cls( scale * x / 10000.0 )
+       
+    def __repr__(self):
+        return f"{self.value}"       
+
+    def __float__(self):
+        return float(self.value)
+
+    def __int__(self):
+        return int(self.value)
+
+# ================== Math Functions =========================================
+    
+    def __abs__(self):
+        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.")
+            return Coordinate(self.value / other)
+        elif isinstance(other, Coordinate):
+            if other.value == 0:
+                raise ZeroDivisionError("Division by zero is not allowed.")
+            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)
+        elif isinstance(other, Coordinate):
+            return Coordinate(self.value + other.value)
+        return NotImplemented
+
+    def __sub__(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 __rtruediv__(self, other):
+        return self.__div__(other)
+    
+    def __rmul__(self, other):
+        return self.__mul__(other)
+    
+    def __radd__(self, other):
+        return self.__add__(other)
+    
+    def __rsub__(self, other):
+        return self.__sub__(other)
+
+    def __lt__(self, other):
+        if isinstance(other, Coordinate):
+            return self.value < other.value
+        elif isinstance(other, (int, float)):
+            return self.value < other
+        return NotImplemented
+
+    def __gt__(self, other):
+        if isinstance(other, Coordinate):
+            return self.value > other.value
+        elif isinstance(other, (int, float)):
+            return self.value > other
+        return NotImplemented
+
+    def __le__(self, other):
+        return self < other or self == other
+
+    def __ge__(self, other):
+        return self > other or self == other
+  
+# =============================================================================
+#     2D Coordinate Point
+# =============================================================================   
+
+class CoordinatePoint:
+    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})" 
+    
+    def to_int(self):
+        return CoordinatePoint( int(self.x), int(self.y))
+
+    def to_int_tuple(self):
+        return ( int(self.x), int(self.y))
+    
+    def expand(self, size):
+        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
+
+    def offset(self, offset_x, offset_y):
+        
+            self.x = self.x + offset_x
+            self.y = self.y + offset_y
+            return self
+    
+    def copy(self):
+        return CoordinatePoint(self.x, self.y)
+
+# ================== Math Functions =========================================
+
+    def __abs__(self):
+        return CoordinatePoint( abs(self.x), abs(self.y))
+    
+    
+    def __add__(self, other):
+        if isinstance(other, CoordinatePoint):
+            return CoordinatePoint(self.x + other.x, self.y + other.y)
+        return NotImplemented
+
+    def __sub__(self, other):
+        if isinstance(other, CoordinatePoint):
+            return CoordinatePoint(self.x - other.x, self.y - other.y)
+        return NotImplemented
+
+    def __truediv__(self, other):
+        if isinstance(other, (int, float)):
+            if other == 0:
+                raise ZeroDivisionError("Division by zero is not allowed.")
+            return CoordinatePoint(self.x / other, self.y / other)
+        elif isinstance(other, Coordinate):
+            if other.value == 0:
+                raise ZeroDivisionError("Division by zero is not allowed.")
+            return  CoordinatePoint(self.x / other.x, self.y / other.y)
+        return NotImplemented
+    
+    def __mul__(self, other):
+        if isinstance(other, (int, float)):
+            return CoordinatePoint(self.x * other, self.y * other)
+        elif isinstance(other, CoordinatePoint):
+            return CoordinatePoint(self.x * other.x, self.y * other.y)
+        return NotImplemented
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+    
+    def __radd__(self, other):
+        return self.__add__(other)
+    
+    def __rsub__(self, other):
+        return self.__sub__(other)
+

pyaltiumlib/datatypes/mapping.py

@@ -0,0 +1,13 @@
+class _MappingBase:
+    
+    def __init__(self, value: int):
+        if int(value) not in self._map:
+            raise ValueError(f"Invalid value: {value}")
+        self.value = int(value)
+        self.name = self._map[int(value)]
+
+    def __repr__(self):
+        return f"{self.name}"
+
+    def to_int(self):
+        return self.value