ifemm 0.2.0__py3-none-any.whl

ifemm/__init__.py

@@ -0,0 +1,10 @@
+# pylint: skip-file
+# ifemm/__init__.py
+
+from ifemm.parser import Parser
+
+# Parser import
+FEMMParser = Parser
+
+# API Promises
+__all__ = ["Parser",]

ifemm/constants.py

@@ -0,0 +1,62 @@
+"""
+Filename: constants.py
+
+Description:
+    This file contains constants regarding
+    to the parsing of .ans files.
+"""
+
+# Validate file types for the parser
+FILE_TYPES = [
+    ".ans"
+]
+
+# Validate File Formats
+FILE_FORMATS = [
+    4.0
+]
+
+# Validate Problem Parameters
+PROBLEM_PARAMETERS = [
+    "format",
+    "frequency",
+    "precision",
+    "minangle",
+    "depth",
+    "lengthunits",
+    "coordinates",
+    "problemtype",
+    "comment"
+]
+
+# Validate Block Section Names
+BLOCK_SECTIONS = [
+    "pointprops",
+    "bdryprops",
+    "blockprops",
+    "circuitprops"
+]
+
+# Validate Block Pairs
+BLOCK_PAIRS = {
+    "<beginpoint>": "<endpoint>",
+    "<beginbdry>":  "<endbdry>",
+    "<beginblock>":  "<endblock>",
+    "<begincircuit>": "<endcircuit>"
+}
+
+# Validate Data Section Names
+DATA_SECTIONS = [
+    "numblocklabels",
+    "numarcsegments",
+    "conductorprops",
+    "numpoints",
+    "numsegments",
+    "numholes",
+    "<bhpoints>",
+]
+
+# Validate Solution Section Name
+SOLUTION_SECTION = [
+    "solution"
+]

ifemm/core/__init__.py

@@ -0,0 +1,2 @@
+# pylint: skip-file
+# FEMMInterpreter/parser/__init__.py

ifemm/core/deserialization.py

@@ -0,0 +1,92 @@
+"""
+Filename: deserialization.py
+
+Description:
+    Type conversion for .ans format values.
+    
+    Converts strings to Python primitives:
+    (int, float, complex, bool, null/none, str).
+"""
+
+
+from __future__ import annotations
+from typing import Any
+
+from ifemm.utilities.errors import FailedCasting
+
+
+class Deserialize:
+    """ Deserialization from text to primitives """
+    @classmethod
+    def cast(cls, text: str) -> int | float | complex | bool | None | str:
+        """ Converts text to python primitives """
+        if not isinstance(text, str):
+            err = f"Expected str, got {type(text).__name__}"
+            raise FailedCasting(text, err)
+
+        text = text.strip()
+        if cls.is_quoted(text):
+            # Handles quoted strings first
+            return str(cls.strip_quotes(text))
+
+        # Try integer value
+        try: return int(text)
+        except ValueError: pass
+
+        # Try float
+        try: return float(text)
+        except ValueError: pass
+
+        # Try complex
+        try: return complex(text)
+        except ValueError: pass
+
+        # Check boolean
+        lower = text.lower()
+        if lower == "true": return True
+        if lower == "false": return False
+
+        # Check null/None
+        if text.lower() in ("null", "none"): return None
+
+        # Default to string
+        return str(text)
+
+    @classmethod
+    def cast_list(cls, items: list[str]) -> list[Any]:
+        """ Casts values within list into primitives """
+        casted_list = []
+
+        for item in items:
+            # Casts each item as a python primitive
+            casted_list.append(cls.cast(item))
+
+        return casted_list
+
+    @classmethod
+    def is_quoted(cls, text: str) -> bool:
+        """ Check if text is surrounded by quotes """
+        text = text.strip()
+        if len(text) < 2:
+            # Empty quoted text Ex. ("")
+            return False
+
+        if text.startswith('"') and text.endswith('"'):
+            # Start and end with double quotes
+            return True
+
+        if text.startswith("'") and text.endswith("'"):
+            # Start and end with single quotes
+            return True
+
+        return False
+
+    @classmethod
+    def strip_quotes(cls, text: str) -> str:
+        """ Removes surrounding quotes if present """
+        text = text.strip()
+        if cls.is_quoted(text):
+            # Removes double quotation ref. "{Text}"
+            return text[1:-1]
+
+        return text

ifemm/core/states.py

@@ -0,0 +1,19 @@
+"""
+Filename: state.py
+
+Description:
+    This file contains the parser state
+    allowing for access across modules
+    without circular implements.
+"""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ParserState:
+    """ Stores the state of the parser """
+    index: int = 0
+    section: str | None = None
+    block: str | None = None
+    content: dict | None = None

ifemm/core/syntax.py

@@ -0,0 +1,181 @@
+"""
+Filename: syntax.py
+
+Description:
+    Syntaxes for .ans format.
+    
+    Handles block section and data 
+    section parsing.
+"""
+
+from ifemm.core.states import ParserState
+from ifemm.utilities.errors import ParserError
+from ifemm.core.deserialization import Deserialize
+
+from ifemm.constants import BLOCK_PAIRS, DATA_SECTIONS
+
+
+class BlockExtraction:
+    """ Extract arbitrary block section data from .ans format """
+    @classmethod
+    def extract(
+        cls, lines: list[str], items: int, state: ParserState
+    ) -> tuple[dict, ParserState]:
+        """ Extracts the block section """
+        if items == 0:
+            # If the entry has zero data. Returns None
+            return {}, state
+
+        block = {}
+        num_item = 0
+
+        # Initializes the first item
+        block[num_item] = {}
+        while state.index < len(lines):
+            line = lines[state.index].strip()
+            state.index += 1
+
+            if cls._is_new_blocks(line):
+                state.block = line.strip().lower()
+                continue
+
+            if state.block and cls._is_close_block(line, state):
+                state.block = None
+                num_item += 1
+
+                # Returns the result after iteration across items
+                if num_item == items: return block, state
+
+                # Adds the entry for the next item
+                block[num_item] = {}
+                continue
+
+            if state.block:
+                # Extracts block and cases the values within the block
+                name, raw_value = cls._extract_block_value(line, state)
+                value = Deserialize.cast(raw_value)
+
+                if name in DATA_SECTIONS:
+                    # Parses the data section syntaxes
+                    data, state = DataExtraction.extract(lines, value, state)
+                    block[num_item][name] = data
+                    continue
+
+                # Adds the name and value to the block and section
+                block[num_item][name] = value
+                continue
+
+        msg = f"Failed to parse block section, block: {block}, items: {items}"
+        raise ParserError(cls.__name__, msg)
+
+    @classmethod
+    def _is_new_blocks(cls, line: str) -> bool:
+        """ Checks if its a block section """
+        if line.lower() in BLOCK_PAIRS:
+            return True
+
+        return False
+
+    @classmethod
+    def _is_close_block(cls, line: str, state: ParserState) -> bool:
+        if state.block is None:
+            return False
+
+        if line.lower() in BLOCK_PAIRS[state.block]:
+            return True
+
+        return False
+
+    @classmethod
+    def _extract_block_value(cls, line: str, state: ParserState) -> tuple[str, str]:
+        """ Extract block name and value from line """
+        equal_sign = line.find("=")
+        if equal_sign == -1:
+            msg = f"Malformed block section found in {line!r}, Index: {state.index}"
+            raise ParserError(cls.__name__, msg)
+
+        # Returns stripped lower name and stripped value
+        return line[:equal_sign-1].strip().lower(), line[equal_sign+1:].strip()
+
+
+class DataExtraction:
+    """ Extract arbitrary data section from .ans format """
+    @classmethod
+    def extract(
+        cls, lines: list[str], items: int, state: ParserState
+    ) -> tuple[dict, ParserState]:
+        """ Extracts the data section """
+        if items == 0:
+            # If the entry has zero data. Returns None
+            return {}, state
+
+        data = {}
+        num_item = 0
+        while state.index < len(lines):
+            line = lines[state.index].strip()
+            state.index += 1
+
+            # Splits the line into values
+            values = line.split()
+            data[num_item] = Deserialize.cast_list(values)
+
+            num_item += 1
+
+            # Returns the result after iteration across items
+            if num_item == items: return data, state
+
+        msg = "Failed to parse data section"
+        raise ParserError(cls.__name__, msg)
+
+
+class SolutionExtraction:
+    """ Extract arbitrary solution data from .ans format"""
+    @classmethod
+    def extract(cls, lines: list[str], state: ParserState) -> tuple[dict, ParserState]:
+        """ Extracts the solution data """
+        data = {}
+        rows = []
+        current_item = None
+
+        while state.index < len(lines):
+            line = lines[state.index].strip()
+            state.index += 1
+
+            # Splits the line into values
+            raw_values = line.split()
+            cast_values = Deserialize.cast_list(raw_values)
+
+            if len(raw_values) == 1:
+                # Updates the section name based off items
+                if current_item is not None and rows:
+                    data[current_item] = cls._transpose(rows)
+                    rows = []
+
+                current_item = cast_values[0]
+                continue
+
+            # Skip orphaned data
+            if current_item is None: continue
+
+            rows.append(cast_values)
+
+        if current_item is not None and rows:
+            data[current_item] = cls._transpose(rows)
+
+        return data, state
+
+    @classmethod
+    def _transpose(cls, rows: list[list]) -> list[list]:
+        """ Transpose rows into columns """
+        # Skips transposing and returns an empty array
+        if not rows: return []
+
+        # Creates a list of columns to transpose.
+        num_cols = len(rows[0])
+        transposed = [[] for _ in range(num_cols)]
+
+        for row in rows:
+            for col_idx, value in enumerate(row):
+                transposed[col_idx].append(value)
+
+        return transposed

ifemm/interpreter/__init__.py

@@ -0,0 +1,2 @@
+# pylint: skip-file
+# FEMMInterpreter/interpreter/__init__.py

ifemm/interpreter/attributes.py

@@ -0,0 +1,33 @@
+"""
+Filename: attributes.py
+
+Descriptions:
+    Defines the `Attribute` structure
+    for the `.ans` files.
+"""
+
+from __future__ import annotations
+
+from ifemm.constants import FILE_FORMATS
+from ifemm.utilities.errors import FormatNotSupported, AttributeLoadingFailed
+from ifemm.interpreter.magnetic.schema import MagneticData 
+
+
+class AttributeLoader:
+    """ Attribute loader for `.ans` files """
+    @classmethod
+    def load(cls, data: dict, file_type: str) -> MagneticData:
+        """ Loads data into type specific structure """
+
+        file_format = data["format"]
+        if file_format not in FILE_FORMATS:
+            # File format not supported currently by the interpreter
+            raise FormatNotSupported(file_format)
+
+        match file_type:
+            case ".ans":
+                # Returns the magnetic data as attribute class
+                return MagneticData(data)
+
+            case _:
+                raise AttributeLoadingFailed(file_type)

ifemm/interpreter/magnetic/__init__.py

@@ -0,0 +1,2 @@
+# pylint: skip-file
+# FEMMInterpreter/interpreter/magnetic/__init__.py

ifemm/interpreter/magnetic/definitions.py

@@ -0,0 +1,127 @@
+"""
+Filename: definitions.py
+
+Description:
+    Definitions for magnetic solutions.
+"""
+
+from __future__ import annotations
+from typing import Any
+
+from abc import ABC
+from dataclasses import dataclass, fields
+
+
+@dataclass(slots=True, repr=False)
+class Definition(ABC):
+    """ Abstract definition class """
+    name: str
+
+    def __repr__(self):
+        """ Returns the loaders direct members """
+        attributes = [field.name for field in fields(self)]
+        items = ', '.join(attributes)
+        if self.name is None:
+            return f'Definition({items})'
+        return f'{self.name}({items})'
+
+
+@dataclass(slots=True, repr=False)
+class MaterialDefinition(Definition):
+    """ Defines a magnetic material """
+    name: str
+    permeability: tuple[float, float]
+    coercive_force: float
+    coercive_angle: float
+    current_density: tuple[float, float]
+    conductivity: float
+    lamination_thickness: float
+    hysteresis_angle: float
+    hysteresis_angle_x: float
+    hysteresis_angle_y: float
+    lamination_type: int
+    lamination_fill: float
+    num_strands: int
+    wire_diameter: float
+    bh_curve: list[tuple[float, float]]
+
+    @classmethod
+    def define(cls, entry: dict[str, Any]) -> MaterialDefinition:
+        """ Self-constructs the magnetic material from entry """
+        bh_data = entry.get("<bhpoints>", {})
+        bh_curve = [(v[0], v[1]) for v in bh_data.values()] if bh_data else []
+
+        return cls(
+            entry["<blockname>"],
+            (entry["<mu_x>"], entry["<mu_y>"]),
+            entry["<h_c>"],
+            entry["<h_cangle>"],
+            (entry["<j_re>"], entry["<j_im>"]),
+            entry["<sigma>"],
+            entry["<d_lam>"],
+            entry["<phi_h>"],
+            entry["<phi_hx>"],
+            entry["<phi_hy>"],
+            entry["<lamtype>"],
+            entry["<lamfill>"],
+            entry["<nstrands>"],
+            entry["<wired>"],
+            bh_curve
+        )
+
+
+@dataclass(slots=True, repr=False)
+class BoundaryDefinition(Definition):
+    """ Defines a boundary condition """
+    name: str
+    boundary_type: int
+    prescribed_a: float
+    prescribed_a_x: float
+    prescribed_a_y: float
+    phase_angle: float
+    mixed_c0: float
+    mixed_c0_imag: float
+    mixed_c1: float
+    mixed_c1_imag: float
+    mu_ssd: float
+    sigma_ssd: float
+    inner_angle: float
+    outer_angle: float
+
+    @classmethod
+    def define(cls, entry: dict[str, Any]) -> BoundaryDefinition:
+        """ Self-constructs the boundary condition from entry """
+        return cls(
+            entry["<bdryname>"],
+            entry["<bdrytype>"],
+            entry["<a_0>"],
+            entry["<a_1>"],
+            entry["<a_2>"],
+            entry["<phi>"],
+            entry["<c0>"],
+            entry["<c0i>"],
+            entry["<c1>"],
+            entry["<c1i>"],
+            entry["<mu_ssd>"],
+            entry["<sigma_ssd>"],
+            entry["<innerangle>"],
+            entry["<outerangle>"]
+        )
+
+@dataclass(slots=True, repr=False)
+class CircuitDefinition(Definition):
+    """ Defines a circuit """
+    name: str
+    total_amps_real: float
+    total_amps_imag: float
+    circuit_type: int
+
+    @classmethod
+    def define(cls, entry: dict[str, Any]) -> CircuitDefinition:
+        """ Self-constructs the circuit from entry """
+        return cls(
+            entry["<circuitname>"],
+            entry["<totalamps_re>"],
+            entry["<totalamps_im>"],
+            entry["<circuittype>"]
+        )

ifemm/interpreter/magnetic/schema.py

@@ -0,0 +1,180 @@
+"""
+Filename: schema.py
+
+Description:
+    Magnetic attribute structure
+    for FEMM magnetostatics and
+    AC simulations.
+"""
+
+from math import pi
+from typing import Any
+from scipy.interpolate import NearestNDInterpolator, griddata
+
+from numpy import (
+    column_stack as np_column_stack,
+    linspace as np_linspace,
+    meshgrid as np_meshgrid,
+    array as np_array,
+    gradient as np_gradient,
+)
+
+from ifemm.interpreter.magnetic.definitions import (
+    MaterialDefinition,
+    BoundaryDefinition,
+    CircuitDefinition
+)
+
+
+_LENGTH_TO_SI = {
+    "meters": 1.0,
+    "centimeters": 1e-2,
+    "millimeters": 1e-3,
+    "inches": 2.54e-2,
+    "mils": 2.54e-5,
+}
+
+
+class MagneticData:
+    """ Magnetic Attribute Data """
+    def __init__(self, data: dict) -> None:
+        """ Initializes the class and loads data into attributes """
+        self.data = data
+
+        # Loads variables into attributes
+        self._load_top_level()
+        self._load_boundaries()
+        self._load_materials()
+        self._load_circuits()
+
+        # Creates the A potential map
+        self._constructs_potential_map()
+
+    @property
+    def length_scale(self) -> float:
+        """ Conversion factor from model length units to metres. """
+        try:
+            return _LENGTH_TO_SI[self.length_unit.lower()]
+
+        except KeyError:
+            msg = f"Unsupported FEMM length unit: {self.length_unit}"
+            raise ValueError(msg) from None
+
+    def _constructs_potential_map(self, eps: float = 1e-6) -> None:
+        """ Constructs the vector potential map """
+        solution = next(iter(self.data["solution"]))
+
+        # Convert to three lists for each dimension
+        self.vector_x = self.data["solution"][solution][0]
+        self.vector_y = self.data["solution"][solution][1]
+        self.vector_a = self.data["solution"][solution][2]
+
+        # Converts flux to a-potential for axisymmetric solutions
+        if self.problem_type == "axisymmetric":
+            converted = []
+            for r, a in zip(self.vector_x, self.vector_a):
+                if r > eps:
+                    converted.append(a / (2.0 * pi * r * self.length_scale))
+                else:
+                    converted.append(0.0)
+            self.vector_a = converted
+
+        # Convert to numpy arrays for interpolation
+        points = np_column_stack((self.vector_x, self.vector_y))
+        values = np_array(self.vector_a)
+
+        # Create the interpolation function
+        self._interpolator = NearestNDInterpolator(points, values)
+
+    def point_potential(self, x: float, y: float) -> float:
+        """ Return the magnetic vector potential A at point (x, y). """
+        result = self._interpolator(x, y)
+
+        # NearestNDInterpolator always returns a value
+        return result
+
+    def field_potential(self, resolution: int = 1000) -> tuple[Any, Any, Any]:
+        """ Returns the interpolated potential field. """
+        x_min, x_max = min(self.vector_x), max(self.vector_x)
+        y_min, y_max = min(self.vector_y), max(self.vector_y)
+
+        # Creates a x and y space
+        xi = np_linspace(x_min, x_max, resolution)
+        yi = np_linspace(y_min, y_max, resolution)
+        x_space, y_space = np_meshgrid(xi, yi)
+
+        # Interpolate A onto x, y space
+        a_grid = griddata(
+            (self.vector_x, self.vector_y),
+            self.vector_a,
+            (x_space, y_space),
+            method='linear'
+        )
+
+        # Returns the X, Y and A spaces
+        return x_space, y_space, a_grid
+
+    def b_field(self, resolution: int = 1000) -> tuple[Any, Any, Any, Any]:
+        """ Returns the interpolated B field (Bx, By) from the vector potential A. """
+        x_space, y_space, a_grid = self.field_potential(resolution)
+
+        scale = self.length_scale
+
+        # Compute gradients in SI metres
+        dx = (x_space[0, 1] - x_space[0, 0]) * scale
+        dy = (y_space[1, 0] - y_space[0, 0]) * scale
+
+        da_dx = np_gradient(a_grid, dx, axis=1)
+        da_dy = np_gradient(a_grid, dy, axis=0)
+
+        # B = curl(A)
+        bx = da_dy
+        by = -da_dx
+
+        return x_space, y_space, bx, by
+
+    def _load_circuits(self) -> None:
+        """ Loads materials section from the solution """
+        circuits = self.data["circuitprops"]
+
+        for key in circuits:
+            # Sets the circuit definition as attribute
+            circuit = CircuitDefinition.define(circuits[key])
+            setattr(self, circuit.name, circuit)
+
+    def _load_materials(self) -> None:
+        """ Loads materials section from the solution """
+        materials = self.data["blockprops"]
+
+        for key in materials:
+            # Sets the material definition as attribute
+            material = MaterialDefinition.define(materials[key])
+            setattr(self, material.name, material)
+
+    def _load_boundaries(self) -> None:
+        """ Loads boundaries section from the solution """
+        boundaries = self.data["bdryprops"]
+
+        for key in boundaries:
+            # Sets the boundary definition as attribute
+            boundary = BoundaryDefinition.define(boundaries[key])
+            setattr(self, boundary.name, boundary)
+
+    def _load_top_level(self) -> None:
+        """ Loads the top level sections from the solution """
+        # File & Version
+        self.format_version: float = self.data["format"]
+
+        # Problem Definition
+        self.frequency_hz: float = self.data["frequency"]
+        self.solver_precision: float = self.data["precision"]
+        self.min_angle_deg: float = self.data["minangle"]
+
+        # Mesh Settings
+        self.model_depth: float = self.data["depth"]
+        self.length_unit: str = self.data["lengthunits"]
+        self.problem_type: str = self.data["problemtype"]
+        self.coordinate_system: str = self.data["coordinates"]
+
+        # Metadata
+        self.comment_text: str = self.data["comment"]

ifemm/parser.py

@@ -0,0 +1,126 @@
+"""
+Filename: main.py
+
+Description:
+    Domain specific language parser for .ans file
+    
+    Orchestrates parsing the files and producing
+    field representations for layer.
+"""
+
+from pathlib import Path
+
+from ifemm.core.states import ParserState
+from ifemm.core.deserialization import Deserialize
+from ifemm.core.syntax import BlockExtraction, DataExtraction, SolutionExtraction
+from ifemm.constants import FILE_TYPES, BLOCK_SECTIONS, DATA_SECTIONS, SOLUTION_SECTION
+
+from ifemm.utilities.errors import ParserError, FileTypeNotSupported
+from ifemm.interpreter.attributes import AttributeLoader, MagneticData
+
+
+class Parser:
+    """ Parser for .ans file format. """
+    @classmethod
+    def open(cls, filepath: Path | str ) -> MagneticData:
+        """ Parses .ans file into a field representation. """
+        if not isinstance(filepath, (str, Path)):
+            # Raises error for non supported path type
+            msg = f"Invalid path type {type(filepath)!r} for {cls.__name__!r}"
+            raise TypeError(msg)
+
+        # Constructs a path and extracts file type
+        path = Path(filepath)
+        file_type = path.suffix.lower()
+
+        # Raises error for non supported file type
+        if file_type not in FILE_TYPES: raise FileTypeNotSupported(file_type)
+            # Raises error for non supported file type
+
+        lines = cls._read_lines(filepath)
+        data = ParseLines.parse(lines)
+        return AttributeLoader.load(data, file_type)
+
+    @staticmethod
+    def _read_lines(filepath_or_file: Path | str) ->  list[str]:
+        """ Read lines from file path or file-like object. """
+
+        # Convert to Path and validate
+        filepath = Path(filepath_or_file)
+        if not filepath.exists():
+            raise FileNotFoundError(f"File not found: {filepath}")
+
+        with filepath.open('r', encoding='utf-8') as f:
+            return f.readlines()
+
+
+class ParseLines:
+    """ Parses lines for .ans file format. """
+    @classmethod
+    def parse(cls, lines: list[str]) -> dict:
+        """ Parses and extracts logic from raw text into structured results. """
+        state = ParserState()
+        state.content = {}
+
+        while state.index < len(lines):
+            line = lines[state.index].strip()
+            state.index += 1
+
+            if not line:
+                # Skips empty lines
+                continue
+
+            # Extracts the solution and value than casts it in primitives
+            is_section, section = cls._is_section(line)
+            is_value, raw_value = cls._extract_section_value(line)
+
+            value = Deserialize.cast(raw_value)
+
+            if section in BLOCK_SECTIONS:
+                # Parses block section syntaxes
+                data, state = BlockExtraction.extract(lines, value, state)
+                state.content[section] = data
+                continue
+
+            if section in DATA_SECTIONS:
+                # Parses the data section syntaxes
+                data, state = DataExtraction.extract(lines, value, state)
+                state.content[section] = data
+                continue
+
+            if section in SOLUTION_SECTION:
+                # Parse the solution section syntaxes
+                data, state = SolutionExtraction.extract(lines, state)
+                state.content[section] = data
+                continue
+
+            if is_section and is_value:
+                # Adds the section value under section name
+                state.content[section] = value
+                continue
+
+            return state.content
+        return state.content
+
+    @classmethod
+    def _is_section(cls, line: str) -> tuple[bool, str]:
+        """ Check if line defines a section [name]. """
+        line = line.strip()
+        if not line.startswith('['):
+            return False, ""
+
+        closing_bracket = line.find(']')
+        if closing_bracket == -1:
+            msg = "closing bracket not found in-line"
+            raise ParserError(cls.__name__, msg)
+
+        return True, line[1:closing_bracket].lower()
+
+    @classmethod
+    def _extract_section_value(cls, line: str) -> tuple[bool, str]:
+        """ Extract section or subsection values. """
+        equal_sign = line.find("=")
+        if equal_sign == -1:
+            return False, ""
+
+        return True, line[equal_sign+1:].strip()

ifemm/utilities/__init__.py

@@ -0,0 +1,2 @@
+# pylint: skip-file
+# FEMMInterpreter/utilities/__init__.py

ifemm/utilities/errors.py

@@ -0,0 +1,62 @@
+"""
+Filename: parser_errors.py
+
+Description:
+    Defines the errors classes to ensure 
+    descriptive error messages.
+"""
+
+from typing import Any
+
+from ifemm.constants import FILE_FORMATS, FILE_TYPES
+
+# pylint: disable=line-too-long
+
+# Generic Errors
+class ParserError(ValueError):
+    """ Exception for Parser errors when parsing """
+    def __init__(self, caller: str, error: str):
+        """ Returns a custom error message """
+        msg = f"[] '{caller}' raised error: {error}. "
+        super().__init__(msg)
+
+
+# Specific errors
+class FailedCasting(ValueError):
+    """ Exception for failure during casting """
+    CODE = "E001"
+
+    def __init__(self, text: Any, error: str):
+        """ Returns a failed casting error """
+        msg = f"[{self.CODE}] Failed to cast {text!r} as Python primitive, error: {error!r}"
+        super().__init__(msg)
+
+
+class FileTypeNotSupported(Exception):
+    """ Exception for file type not supported """
+    CODE = "E002"
+
+    def __init__(self, file_type: str):
+        """ Returns a file type not supported error """
+        msg = f"[{self.CODE}] Failed to parse {file_type!r} as not in supported list {FILE_TYPES!r}"
+        super().__init__(msg)
+
+
+class FormatNotSupported(Exception):
+    """ Exception for format not supported """
+    CODE = "E003"
+
+    def __init__(self, file_format: str):
+        """ Returns a format not supported error """
+        msg = f"[{self.CODE}] Failed to parse {file_format!r} as not in supported list {FILE_FORMATS!r}"
+        super().__init__(msg)
+
+
+class AttributeLoadingFailed(Exception):
+    """ Exception for attribute loading failing """
+    CODE = "E004"
+
+    def __init__(self, file_type: str):
+        """ Returns a loading failure error """
+        msg = f"[{self.CODE}] Failed to load {file_type!r} attributes into attribute structure"
+        super().__init__(msg)

ifemm-0.2.0.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.5
+Name: ifemm
+Version: 0.2.0
+Summary: A python library for interpreting FEMM solution files
+Project-URL: Homepage, https://github.com/wgbowley/ifemm
+Project-URL: Bug Tracker, https://github.com/wgbowley/ifemm/issues
+Author-email: William Bowley <wgrantbowley@gmail.com>
+Maintainer-email: William Bowley <wgrantbowley@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 William Bowley
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: FEM,FEMM,Parsing,format
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scipy>=1.10.0
+Description-Content-Type: text/markdown
+
+<!--
+Color Palette:
+#FFFFFF - pure white 
+#00FFFF - pure, highly saturated shade of Cyan  
+
+It's a simple piece of kit, but being able to integrate
+FEMM solutions directly into the pipeline is extremely
+useful.
+
+- William Bowley, 2026-08-17
+
+P.S: Thanks for downloading the ifemm repository `▽`ʃ♡
+-->
+
+### Overview
+
+![Version](https://img.shields.io/badge/Version-0.2.0-FFFFFF?style=flat-square)
+![License](https://img.shields.io/badge/License-MIT-00FFFF?style=flat-square&color=00FFFF)
+![Python Version](https://img.shields.io/badge/Python-3.10%2B-FFFFFF?style=flat-square)
+[![PyPI Downloads](https://img.shields.io/pepy/dt/femminterpreter?label=downloads\&style=flat-square\&color=00FFFF)](https://pepy.tech/projects/femminterpreter)
+
+A Python library for interpreting Finite Element Method Magnetic (FEMM) files and exposing FEMM solution data 
+through a Python attribute-based interface. `ifemm` exposes the `A-field` as `A(x,y)`, independent of planar or axisymmetric coordinate systems.
+
+#### Proposed Integration
+
+```
+FEMM Setup & Solve → FEMM (.ans) → ifemm → Reduced Order Models / Analytical Models
+```
+
+---
+
+### Example
+
+An example of a dipole being plotted can be found in [/examples](examples/) with `.ans` and `.py` files.
+
+<div align="center">
+  <img 
+    src="https://raw.githubusercontent.com/wgbowley/FEMMInterpreter/refs/heads/main/media/planar_llc_b_field.png" 
+    alt="B-field of transformer" 
+    style="max-width: 600px"
+  >
+  <p>
+  <em> B-field of a planar LLC transformer from FEMM (.ans) </em>
+  </p>
+</div>
+
+---
+
+### Quick Start
+
+```py
+from ifemm import Parser
+
+# Imports the parser and parses the .ans file
+PATH = "examples/magnetostatic.ans"
+data = Parser.open(PATH)
+
+# Result as a float with implicit unit of wb/length_unit
+a_potential = data.point_potential(0, 0)
+```
+
+---
+
+### Installation
+
+To install,
+
+```
+pip install ifemm
+```
+
+---
+
+### Documentation
+
+Full documentation is available in the [`docs/`](https://github.com/wgbowley/ifemm/tree/main/docs) folder, including API reference, changelog, and contributors.
+
+---

ifemm-0.2.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+ifemm/__init__.py,sha256=Kggl2PH-Ua9TIBk73jLUI-4VrMG5JzAQcUAfSoRbUHA,147
+ifemm/constants.py,sha256=6452Yild1ElbwkJN9CJM0zNrfZfF7szEaYqf8JVh0QA,1009
+ifemm/parser.py,sha256=arg3s1XrFc3dud5crcOeTJF9aFm9w7RYfnj07QRPl6Q,4297
+ifemm/core/__init__.py,sha256=d9hDTekERYUfOF1O0Ur9blpDDx2_w34VQT6p0KDDryA,56
+ifemm/core/deserialization.py,sha256=TEKWAH-SktCI_0a7wMnQQdKVn1vwCTVOrLvLjHOs51k,2454
+ifemm/core/states.py,sha256=lA033cCIj1aVEepIU5RPlavl8ii8YR2_ZD63c7RvZKg,374
+ifemm/core/syntax.py,sha256=agtoF1km1oqPzuIaJfJmkWzDnEypGBVMzKGeiLi5W8w,5593
+ifemm/interpreter/__init__.py,sha256=rH5wLOJMxWUN1WaCQY8hINVBi4pzqmtGLBV3PMx3bR0,62
+ifemm/interpreter/attributes.py,sha256=KKR0oJ2FV3DTpnc0pM1Yus6JIrPELW5ATi0_XT21Myk,968
+ifemm/interpreter/magnetic/__init__.py,sha256=72nvrj9WhEkcmKyV2rOR0Th3qK5_dg8wTXZ49mnQw6g,71
+ifemm/interpreter/magnetic/definitions.py,sha256=iDPgml7A7YT9-fZGgj8Oa0962yxuFoHFSojknPm7wd8,3479
+ifemm/interpreter/magnetic/schema.py,sha256=tOh7oFu0vqSWdQ1KotFCmLi7hrgK-EI8X7QA5xI1gYQ,5882
+ifemm/utilities/__init__.py,sha256=df7bmOOqt3lTii-yT4Z5ywRaf7RSjg2RSESm3DNuFEk,59
+ifemm/utilities/errors.py,sha256=WHSQS6qVqEjL5EKVQRGw7YRD4wsZRCm0vUNVtIkWaA0,1855
+ifemm-0.2.0.dist-info/METADATA,sha256=bd0rgi2oT62lO94haArd_9haHQ52CPrJr3RfijsPzOQ,4066
+ifemm-0.2.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+ifemm-0.2.0.dist-info/licenses/LICENSE,sha256=PB4SZBAK73vxATTUsk5y_0XiWa0lHuZREvj3y4Syr04,1071
+ifemm-0.2.0.dist-info/RECORD,,

ifemm-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

ifemm-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 William Bowley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.