radia 1.3.2__py3-none-any.whl → 1.3.4__py3-none-any.whl

python/radia_ngsolve_utils.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env python
+"""
+radia_ngsolve_utils.py - Utilities for Radia-NGSolve integration
+
+This module provides high-level utilities for working with Radia and NGSolve together,
+including mesh import and VTK export functionality.
+
+Author: Radia Development Team
+Created: 2025-11-22
+Version: 1.0.0
+
+Key Features
+------------
+- Import Netgen/OCC tetrahedral meshes to Radia
+- Export Radia geometry to VTK for visualization
+- Export NGSolve solutions to VTK
+- Unified interface for both solvers
+
+Functions
+---------
+create_radia_from_mesh : Import Netgen mesh to Radia with VTK export
+export_ngsolve_vtk : Export NGSolve solution to VTK
+export_radia_vtk : Export Radia geometry to VTK
+
+Example
+-------
+>>> import radia as rad
+>>> from ngsolve import Mesh
+>>> from netgen.occ import Box, OCCGeometry
+>>> from radia_ngsolve_utils import create_radia_from_mesh, export_radia_vtk
+>>>
+>>> # Setup
+>>> rad.FldUnits('m')
+>>>
+>>> # Create mesh
+>>> geo = OCCGeometry(Box((-0.5, -0.5, -0.5), (0.5, 0.5, 0.5)))
+>>> mesh = Mesh(geo.GenerateMesh(maxh=0.2))
+>>>
+>>> # Import to Radia and export VTK
+>>> mag = create_radia_from_mesh(
+...     mesh,
+...     material={'magnetization': [0, 0, 1.2]},
+...     vtk_filename='magnet'
+... )
+>>>
+>>> # Apply material and solve
+>>> rad.MatApl(mag, rad.MatStd('NdFeB', 1.2))
+>>> rad.Solve(mag, 0.0001, 10000)
+>>>
+>>> # Export final geometry
+>>> export_radia_vtk(mag, 'magnet_solved')
+"""
+
+import os
+import radia as rad
+from netgen_mesh_import import netgen_mesh_to_radia
+from radia_vtk_export import exportGeometryToVTK
+
+
+def create_radia_from_mesh(mesh, material=None, units='m', combine=True,
+                           verbose=False, material_filter=None, vtk_filename=None):
+    """
+    Import Netgen mesh to Radia and optionally export to VTK.
+
+    This is a convenience wrapper around netgen_mesh_to_radia that adds
+    automatic VTK export functionality.
+
+    Parameters
+    ----------
+    mesh : ngsolve.Mesh
+        NGSolve mesh object to import
+    material : dict, optional
+        Material properties. Should contain 'magnetization' key with [Mx, My, Mz] in Tesla.
+        Default: {'magnetization': [0, 0, 0]}
+    units : str, optional
+        Length units: 'm' (meters) or 'mm' (millimeters)
+        Default: 'm' (recommended for NGSolve integration)
+    combine : bool, optional
+        If True, combine all tetrahedra into single container
+        If False, return list of individual tetrahedra
+        Default: True
+    verbose : bool, optional
+        Print detailed import information
+        Default: False
+    material_filter : str, optional
+        Filter mesh by material name (e.g., 'magnetic', 'air')
+        If None, import all materials
+        Default: None
+    vtk_filename : str, optional
+        If provided, export geometry to VTK file with this name (without .vtk extension)
+        Default: None (no VTK export)
+
+    Returns
+    -------
+    int or list
+        Radia object ID (if combine=True) or list of object IDs (if combine=False)
+
+    Example
+    -------
+    >>> from netgen.occ import Box, OCCGeometry
+    >>> from ngsolve import Mesh
+    >>> import radia as rad
+    >>> from radia_ngsolve_utils import create_radia_from_mesh
+    >>>
+    >>> rad.FldUnits('m')
+    >>> geo = OCCGeometry(Box((0, 0, 0), (0.1, 0.1, 0.1)))
+    >>> mesh = Mesh(geo.GenerateMesh(maxh=0.03))
+    >>>
+    >>> magnet = create_radia_from_mesh(
+    ...     mesh,
+    ...     material={'magnetization': [0, 0, 1.2]},
+    ...     vtk_filename='my_magnet'
+    ... )
+    >>> # Creates my_magnet.vtk in current directory
+    """
+    # Import mesh to Radia
+    radia_obj = netgen_mesh_to_radia(
+        mesh=mesh,
+        material=material,
+        units=units,
+        combine=combine,
+        verbose=verbose,
+        material_filter=material_filter
+    )
+
+    # Export to VTK if requested
+    if vtk_filename is not None:
+        export_radia_vtk(radia_obj, vtk_filename)
+
+    return radia_obj
+
+
+def export_radia_vtk(radia_obj, filename):
+    """
+    Export Radia geometry to VTK file.
+
+    Parameters
+    ----------
+    radia_obj : int
+        Radia object ID
+    filename : str
+        Output filename without .vtk extension
+
+    Returns
+    -------
+    str
+        Full path to created VTK file
+
+    Example
+    -------
+    >>> import radia as rad
+    >>> from radia_ngsolve_utils import export_radia_vtk
+    >>>
+    >>> magnet = rad.ObjRecMag([0, 0, 0], [10, 10, 10], [0, 0, 1])
+    >>> vtk_path = export_radia_vtk(magnet, 'my_magnet')
+    >>> print(f"VTK exported to: {vtk_path}")
+    """
+    # Ensure .vtk extension
+    if not filename.endswith('.vtk'):
+        base_filename = filename
+        filename = filename + '.vtk'
+    else:
+        base_filename = filename[:-4]
+
+    # Export using radia_vtk_export
+    exportGeometryToVTK(radia_obj, base_filename)
+
+    # Get absolute path
+    vtk_path = os.path.abspath(filename)
+
+    return vtk_path
+
+
+def export_ngsolve_vtk(mesh, gridfunction, filename, field_name='solution'):
+    """
+    Export NGSolve solution to VTK file.
+
+    Uses NGSolve's built-in VTK export functionality.
+
+    Parameters
+    ----------
+    mesh : ngsolve.Mesh
+        NGSolve mesh
+    gridfunction : ngsolve.GridFunction
+        Solution to export (e.g., H-field, B-field, potential)
+    filename : str
+        Output filename without .vtk extension
+    field_name : str, optional
+        Name for the field in VTK file
+        Default: 'solution'
+
+    Returns
+    -------
+    str
+        Full path to created VTK file
+
+    Example
+    -------
+    >>> from ngsolve import *
+    >>> from netgen.occ import Box, OCCGeometry
+    >>> from radia_ngsolve_utils import export_ngsolve_vtk
+    >>>
+    >>> geo = OCCGeometry(Box((0, 0, 0), (1, 1, 1)))
+    >>> mesh = Mesh(geo.GenerateMesh(maxh=0.2))
+    >>> fes = H1(mesh, order=2)
+    >>> gfu = GridFunction(fes)
+    >>> # ... solve for gfu ...
+    >>>
+    >>> vtk_path = export_ngsolve_vtk(mesh, gfu, 'solution', 'phi')
+    >>> print(f"NGSolve VTK exported to: {vtk_path}")
+    """
+    from ngsolve import VTKOutput
+
+    # Ensure .vtk extension
+    if filename.endswith('.vtk'):
+        filename = filename[:-4]
+
+    # Create VTK output
+    vtk = VTKOutput(
+        ma=mesh,
+        coefs=[gridfunction],
+        names=[field_name],
+        filename=filename,
+        subdivision=2
+    )
+    vtk.Do()
+
+    # Get absolute path
+    vtk_path = os.path.abspath(filename + '.vtk')
+
+    return vtk_path
+
+
+def export_comparison_vtk(mesh_ngsolve, gfu_ngsolve, radia_obj,
+                         prefix='comparison', ngsolve_field_name='H_ngsolve'):
+    """
+    Export both NGSolve and Radia results to VTK for comparison.
+
+    Creates two VTK files:
+    - {prefix}_ngsolve.vtk : NGSolve solution
+    - {prefix}_radia.vtk : Radia geometry
+
+    Parameters
+    ----------
+    mesh_ngsolve : ngsolve.Mesh
+        NGSolve mesh
+    gfu_ngsolve : ngsolve.GridFunction
+        NGSolve solution
+    radia_obj : int
+        Radia object ID
+    prefix : str, optional
+        Prefix for output filenames
+        Default: 'comparison'
+    ngsolve_field_name : str, optional
+        Name for NGSolve field in VTK
+        Default: 'H_ngsolve'
+
+    Returns
+    -------
+    tuple of str
+        (ngsolve_vtk_path, radia_vtk_path)
+
+    Example
+    -------
+    >>> from radia_ngsolve_utils import export_comparison_vtk
+    >>>
+    >>> # After solving both NGSolve and Radia...
+    >>> ngsolve_vtk, radia_vtk = export_comparison_vtk(
+    ...     mesh, gfu, radia_system,
+    ...     prefix='cube_benchmark',
+    ...     ngsolve_field_name='H_field'
+    ... )
+    >>> print(f"NGSolve: {ngsolve_vtk}")
+    >>> print(f"Radia:   {radia_vtk}")
+    """
+    ngsolve_filename = f"{prefix}_ngsolve"
+    radia_filename = f"{prefix}_radia"
+
+    ngsolve_vtk = export_ngsolve_vtk(mesh_ngsolve, gfu_ngsolve,
+                                     ngsolve_filename, ngsolve_field_name)
+    radia_vtk = export_radia_vtk(radia_obj, radia_filename)
+
+    return ngsolve_vtk, radia_vtk
+
+
+# Module-level constants
+__version__ = '1.0.0'
+__all__ = [
+    'create_radia_from_mesh',
+    'export_radia_vtk',
+    'export_ngsolve_vtk',
+    'export_comparison_vtk'
+]

python/radia_vtk_export.py

@@ -7,10 +7,32 @@ Functions for exporting Radia geometry to VTK format for visualization
 in ParaView and other VTK-compatible tools.
 """
 
-import radia as rad
 import csv
 from itertools import accumulate
 
+def _get_radia_length_unit():
+	"""
+	Get current Radia length unit by querying rad.FldUnits().
+
+	Returns:
+		tuple: (unit_name, scale_to_meters)
+		       ('mm', 0.001) if Radia is using millimeters
+		       ('m', 1.0) if Radia is using meters
+
+	Raises:
+		ValueError: If length unit cannot be determined
+	"""
+	import radia as rad
+
+	units_str = rad.FldUnits()
+
+	if 'Length:  mm' in units_str:
+		return ('mm', 0.001)
+	elif 'Length:  m' in units_str:
+		return ('m', 1.0)
+	else:
+		raise ValueError(f"Cannot determine Radia length unit from: {units_str}")
+
 def chunks(lst, n):
 	"""
 	Yield successive n-sized chunks from a list.
@@ -45,7 +67,8 @@ def exportGeometryToVTK(obj, fileName='radia_Geometry'):
 		>>> mag = rad.ObjRecMag([0,0,0], [10,10,10], [0,0,1])
 		>>> exportGeometryToVTK(mag, 'my_magnet')
 	"""
-	
+	import radia as rad
+
 	vtkData = rad.ObjDrwVTK(obj, 'Axes->False')
 
 	lengths = vtkData['polygons']['lengths']
@@ -55,34 +78,41 @@ def exportGeometryToVTK(obj, fileName='radia_Geometry'):
 	points = vtkData['polygons']['vertices']
 	nPnts = int(len(points)/3)
 
-	# format the points array to be floats rather than double
-	points = [round(num/1000.0, 8) for num in points]		
-	# Note: Converted from mm (Radia units) to m
-	# define the connectivity list
-	conn = list(range(nPnts)) 
+	# Get Radia's current length unit and convert to meters for VTK standard
+	unit_name, scale_to_meters = _get_radia_length_unit()
+	points = [round(num * scale_to_meters, 8) for num in points]
+
 	# define colours array
 	colors = vtkData['polygons']['colors']
 
 	# pre-process the output lists to have chunkLength items per line
-	chunkLength = 9 # this writes 9 numbers per line (9 is the number used in Paraview if data is saved as the VTK Legacy format)
-	offsets = list(chunks(offsets, chunkLength))
+	chunkLength = 9 # this writes 9 numbers per line
 	points = list(chunks(points, chunkLength))
-	conn = list(chunks(conn, chunkLength))
 	colors = list(chunks(colors, chunkLength))
 
-	# write the data to file
+	# write the data to file (VTK Legacy format - most compatible)
 	with open(fileName + ".vtk", "w", newline="") as f:
-		f.write('# vtk DataFile Version 5.1\n')
+		f.write('# vtk DataFile Version 3.0\n')
 		f.write('vtk output\nASCII\nDATASET POLYDATA\n')
 		f.write('POINTS ' + str(nPnts) + ' float\n')
 		writer = csv.writer(f, delimiter=" ")
 		writer.writerows(points)
 		f.write('\n')
-		f.write('POLYGONS ' + str(nPoly+1) + ' ' + str(nPnts) + '\n')
-		f.write('OFFSETS vtktypeint64\n')
-		writer.writerows(offsets)
-		f.write('CONNECTIVITY vtktypeint64\n')  
-		writer.writerows(conn)
+
+		# POLYGONS in classic format (most compatible with all ParaView versions)
+		# Format: nPoly totalSize
+		# Each line: nVertices v1 v2 v3 ...
+		total_size = sum(lengths) + nPoly  # sum of (nVertices + nVertices) for each polygon
+		f.write('POLYGONS ' + str(nPoly) + ' ' + str(total_size) + '\n')
+		for i in range(nPoly):
+			n_vertices = lengths[i]
+			start = offsets[i]
+			end = offsets[i+1]
+			f.write(str(n_vertices))
+			for j in range(start, end):
+				f.write(' ' + str(j))
+			f.write('\n')
+
 		f.write('\n')
 		f.write('CELL_DATA ' + str(nPoly) + '\n')
 		f.write('COLOR_SCALARS Radia_colours 3\n')
@@ -93,6 +123,62 @@ def exportGeometryToVTK(obj, fileName='radia_Geometry'):
 	print(f"  Points: {nPnts}")
 
 
+def exportFieldToVTK(points, field_data, fileName='field_distribution', field_name='B_field'):
+	"""
+	Export magnetic field distribution to VTK Legacy format file.
+
+	Args:
+		points: List of observation points [[x, y, z], ...] in Radia's current units
+		field_data: List of field vectors [[Bx, By, Bz], ...] in Tesla
+		fileName: Output file name (without .vtk extension)
+		field_name: Name for the vector field in VTK file
+
+	Note:
+		Points are automatically converted to meters (VTK standard) based on
+		Radia's current unit setting (queried via rad.FldUnits()).
+	"""
+	import numpy as np
+
+	points = np.array(points)
+	field_data = np.array(field_data)
+
+	if points.shape[0] != field_data.shape[0]:
+		raise ValueError(f"Points ({points.shape[0]}) and field data ({field_data.shape[0]}) must have same length")
+
+	if points.shape[1] != 3 or field_data.shape[1] != 3:
+		raise ValueError("Points and field data must be Nx3 arrays")
+
+	# Get Radia's current length unit
+	unit_name, scale_to_meters = _get_radia_length_unit()
+
+	# Ensure .vtk extension
+	if not fileName.endswith('.vtk'):
+		fileName += '.vtk'
+
+	with open(fileName, 'w') as f:
+		# Header
+		f.write('# vtk DataFile Version 3.0\n')
+		f.write('Magnetic Field Distribution\n')
+		f.write('ASCII\n')
+		f.write('DATASET POLYDATA\n')
+
+		# Points (convert to meters for VTK standard)
+		f.write(f'POINTS {len(points)} float\n')
+		for pt in points:
+			# Convert to meters using detected unit scale
+			f.write(f'{pt[0]*scale_to_meters} {pt[1]*scale_to_meters} {pt[2]*scale_to_meters}\n')
+
+		# Point data (vector field)
+		f.write(f'\nPOINT_DATA {len(points)}\n')
+		f.write(f'VECTORS {field_name} float\n')
+		for B in field_data:
+			f.write(f'{B[0]} {B[1]} {B[2]}\n')
+
+	print(f"VTK field file exported: {fileName}")
+	print(f"  Points: {len(points)}")
+	print(f"  Field: {field_name}")
+
+
 if __name__ == '__main__':
 	"""
 	Demo: Export a simple Radia geometry to VTK format
@@ -101,8 +187,9 @@ if __name__ == '__main__':
 	import os
 
 	# Add build directory to path
-	sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'build', 'lib', 'Release'))
-	sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'dist'))
+	sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'build', 'Release'))
+
+	import radia as rad
 
 	print("=" * 60)
 	print("Radia VTK Export Demo")

{radia-1.3.2.dist-info → radia-1.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: radia
-Version: 1.3.2
+Version: 1.3.4
 Summary: Radia 3D Magnetostatics with NGSolve Integration and OpenMP Parallelization
 Home-page: https://github.com/ksugahar/Radia_NGSolve
 Author: Pascal Elleaume
@@ -88,12 +88,12 @@ pip install radia-ngsolve
 # 1. Build radia.pyd (core module)
 .\Build.ps1
 
-# 2. Build rad_ngsolve.pyd (optional, for NGSolve integration)
+# 2. Build radia_ngsolve.pyd (optional, for NGSolve integration)
 .\Build_NGSolve.ps1
 
 # Outputs:
 # - dist/radia.pyd
-# - build/Release/rad_ngsolve.pyd
+# - build/Release/radia_ngsolve.pyd
 ```
 
 See [README_BUILD.md](README_BUILD.md) for detailed build instructions.
@@ -117,12 +117,12 @@ print(f"Field: {field} T")
 
 ### NGSolve Integration
 
-The `rad_ngsolve` module provides a C++ CoefficientFunction interface for using Radia magnetic fields in NGSolve FEM analysis.
+The `radia_ngsolve` module provides a C++ CoefficientFunction interface for using Radia magnetic fields in NGSolve FEM analysis.
 
 **Function Specification:**
 
 ```python
-rad_ngsolve.RadiaField(radia_obj, field_type='b')
+radia_ngsolve.RadiaField(radia_obj, field_type='b')
 ```
 
 **Parameters:**
@@ -149,7 +149,7 @@ import ngsolve
 from ngsolve import Mesh, H1, GridFunction
 
 import radia as rad
-import rad_ngsolve
+import radia_ngsolve
 
 # Create Radia magnet
 magnet = rad.ObjRecMag([0,0,0], [20,20,20], [0,0,1.2])  # mm units
@@ -157,10 +157,10 @@ rad.MatApl(magnet, rad.MatPM(1.2, 900000, [0,0,1]))  # NdFeB permanent magnet
 rad.Solve(magnet, 0.0001, 10000)
 
 # Create NGSolve CoefficientFunction for different field types
-B_field = rad_ngsolve.RadiaField(magnet, 'b')  # Flux density [T]
-H_field = rad_ngsolve.RadiaField(magnet, 'h')  # Magnetic field [A/m]
-A_field = rad_ngsolve.RadiaField(magnet, 'a')  # Vector potential [T·m]
-M_field = rad_ngsolve.RadiaField(magnet, 'm')  # Magnetization [A/m]
+B_field = radia_ngsolve.RadiaField(magnet, 'b')  # Flux density [T]
+H_field = radia_ngsolve.RadiaField(magnet, 'h')  # Magnetic field [A/m]
+A_field = radia_ngsolve.RadiaField(magnet, 'a')  # Vector potential [T·m]
+M_field = radia_ngsolve.RadiaField(magnet, 'm')  # Magnetization [A/m]
 
 # Use in FEM analysis (NGSolve mesh in meters)
 gf = GridFunction(fes)
@@ -177,13 +177,10 @@ See [examples/Radia_to_NGSolve_CoefficientFunction/](examples/Radia_to_NGSolve_C
 - [docs/DIRECTORY_STRUCTURE.md](docs/DIRECTORY_STRUCTURE.md) - Project structure
 
 ### NGSolve Integration
-- [RAD_NGSOLVE_BUILD_SUCCESS.md](RAD_NGSOLVE_BUILD_SUCCESS.md) - Complete rad_ngsolve documentation
+- [RAD_NGSOLVE_BUILD_SUCCESS.md](RAD_NGSOLVE_BUILD_SUCCESS.md) - Complete radia_ngsolve documentation
 - [examples/Radia_to_NGSolve_CoefficientFunction/README.md](examples/Radia_to_NGSolve_CoefficientFunction/README.md) - NGSolve examples overview
 - [examples/Radia_to_NGSolve_CoefficientFunction/EXAMPLES_GUIDE.md](examples/Radia_to_NGSolve_CoefficientFunction/EXAMPLES_GUIDE.md) - Detailed usage guide
-- [tests/test_rad_ngsolve.py](tests/test_rad_ngsolve.py) - Integration tests
-
-### Visualization
-- [docs/PYVISTA_VIEWER.md](examples/2024_02_03_振分電磁石/PYVISTA_VIEWER.md) - PyVista viewer guide
+- [tests/test_radia_ngsolve.py](tests/test_radia_ngsolve.py) - Integration tests
 
 ### Development
 - [docs/TAB_CONVERSION_REPORT.md](docs/TAB_CONVERSION_REPORT.md) - Code style conversion
@@ -239,7 +236,7 @@ python tests/test_radia.py
 python tests/test_advanced.py
 
 # NGSolve integration test
-python tests/test_rad_ngsolve.py
+python tests/test_radia_ngsolve.py
 
 # OpenMP performance test
 python tests/test_parallel_performance.py
@@ -248,7 +245,7 @@ python tests/test_parallel_performance.py
 pytest tests/
 
 # Run specific test suite
-pytest tests/test_rad_ngsolve.py -v
+pytest tests/test_radia_ngsolve.py -v
 ```
 
 See [tests/README.md](tests/README.md) for detailed testing documentation.
@@ -296,7 +293,7 @@ export_geometry_to_vtk(mag, 'geometry.vtk')
 ### Runtime Requirements
 - Python 3.12
 - NumPy
-- NGSolve (optional, for FEM coupling via rad_ngsolve)
+- NGSolve (optional, for FEM coupling via radia_ngsolve)
 - PyVista (optional, for 3D visualization)
 
 ## Changes from Original Radia
@@ -348,7 +345,7 @@ See:
 
 **This Fork**:
 - OpenMP parallelization
-- NGSolve C++ integration (rad_ngsolve)
+- NGSolve C++ integration (radia_ngsolve)
 - Python 3.12 optimization
 - Build system modernization
 - PyVista integration

radia-1.3.4.dist-info/RECORD

@@ -0,0 +1,17 @@
+python/__init__.py,sha256=oUOAjf_vY8DNy5HRU7oArAMic8urvHCR9yHSi4HFkkQ,47
+python/nastran_mesh_import.py,sha256=CSoVhZCXa85lPiTF2hlspE2clBKOD7-_sCp1bxu_IK0,18147
+python/netgen_mesh_import.py,sha256=UopXk-5bbfj1j9_hyiq8jbjb4SQXnWaeuaC7TDf17wA,19872
+python/rad_ngsolve.pyd,sha256=s5ZvpTIrjYeV_B3vQv5HrtP4u_RaPhvxuZf5aKv3oC0,566272
+python/rad_ngsolve_fast.py,sha256=GkC7ruKy3MESHsO0iRSWsrgLU4-DPPgctOi6pPpsWg4,5675
+python/radia_coil_builder.py,sha256=nQkiAbfhueNvvxUARHdPD0C68ImidHmUQv_q4RsImeY,11253
+python/radia_field_cached.py,sha256=Bjw3ecNe3u7AAXnLob5m_tjYIY7HwB9DpgFg9a-aP_8,9509
+python/radia_ngsolve.pyd,sha256=s5ZvpTIrjYeV_B3vQv5HrtP4u_RaPhvxuZf5aKv3oC0,566272
+python/radia_ngsolve_field.py,sha256=suJr4wacfYFKOkyV-5AQuHWnW5rtUMb0gSSjq8VRSXc,10166
+python/radia_ngsolve_utils.py,sha256=xZCR9DOIKMwdEjmC28rOXVZiWFY5BQYH2VfopfuVBps,8406
+python/radia_pyvista_viewer.py,sha256=JS33Mx4azGI7hUX0bzefc6zJfhv6qfRjM3Kl1bE9Mjs,4275
+python/radia_vtk_export.py,sha256=I8Vyyt9tky78Qw1xPru9f0Rii6QEmdEgTFjQtamyooc,6540
+radia-1.3.4.dist-info/licenses/LICENSE,sha256=yaWxyzG9DpJ44dDNdGni4nukwiZ8pU-r_aW-1tYNAjk,4374
+radia-1.3.4.dist-info/METADATA,sha256=iLmP3uISANgF67d-fTvmh17jl1YNvuHjiEcBvBRkQm0,13202
+radia-1.3.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+radia-1.3.4.dist-info/top_level.txt,sha256=J-z0poNcsv31IHB413--iOY8LoHBKiTHeybHX3abokI,7
+radia-1.3.4.dist-info/RECORD,,