| Name | feax JSON |
| Version |
0.0.4
JSON |
| download |
| home_page | None |
| Summary | A GPU-accelerated finite element analysis framework with JAX. |
| upload_time | 2025-08-18 05:47:26 |
| maintainer | None |
| docs_url | None |
| author | Naruki-Ichihara |
| requires_python | >=3.9 |
| license | None |
| keywords |
jax
cuda
simulation
pinn
|
| VCS |
|
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
<div align="center">
<img src="assets/logo.svg" alt="logo" width=300></img>
</div>
# FEAX
[](LICENSE)
[](https://www.python.org/downloads/)
[](https://github.com/google/jax)
**FEAX** (Finite Element Analysis with JAX) is a compact, high-performance finite element analysis engine built on JAX. It provides an API for solving partial differential equations with automatic differentiation, JIT compilation, and GPU acceleration.
## What is FEAX?
FEAX combines the power of modern automatic differentiation with classical finite element methods. It's designed for:
- **Differentiable Physics**: Compute gradients through entire FE simulations for optimization, inverse problems, and machine learning
- **High Performance**: JIT compilation and vectorization through JAX for maximum computational efficiency
## JAX Transformations in FEAX
<div align="center">
<img src="assets/feax_jax_transformations.svg" alt="JAX Transformations" width="800">
</div>
FEAX leverages JAX's powerful transformation system to enable:
- **Automatic Differentiation**: Compute exact gradients through finite element solvers
- **JIT Compilation**: Compile to optimized machine code for maximum performance
- **Vectorization**: Efficiently process multiple scenarios in parallel with `vmap`
- **Parallelization**: Scale across multiple devices with `pmap`
## Installation
Use pip to install:
```bash
pip install feax
```
To install the latest commit from the main branch:
```bash
pip install git+https://github.com/Naruki-Ichihara/feax.git@main
```
## Key Features
### Differentiable Solvers
```python
import jax
from feax import Problem, InternalVars, create_solver
# Define your physics problem
class Elasticity(Problem):
def get_tensor_map(self):
def stress(u_grad, E):
# Linear elasticity constitutive law
return elastic_stress_tensor(u_grad, E)
return stress
# Create differentiable solver
solver = create_solver(problem, boundary_conditions, options)
# Compute gradients with respect to material properties
grad_fn = jax.grad(lambda params: objective(solver(params)))
gradients = grad_fn(material_parameters)
```
### Architecture
```python
# Separate problem definition from parameters
problem = ElasticityProblem(mesh, vec=3, dim=3)
internal_vars = InternalVars(
volume_vars=(young_modulus, density),
surface_vars=(surface_traction,)
)
# Solve with different parameter sets
solutions = jax.vmap(solver)(parameter_batch)
```
## Installation
### Requirements
- Python 3.10+
- JAX 0.7+
### Install from source
```bash
git clone https://github.com/your-repo/feax.git
cd feax
pip install -e .
```
## Quick Start
Here's a simple linear elasticity example:
```python
import jax
import jax.numpy as np
from feax import Problem, InternalVars, create_solver
from feax import Mesh, SolverOptions, zero_like_initial_guess
from feax import DirichletBCSpec, DirichletBCConfig
from feax.mesh import box_mesh_gmsh
# Define the physics
class LinearElasticity(Problem):
def get_tensor_map(self):
def stress_tensor(u_grad, E):
nu = 0.3 # Poisson's ratio
mu = E / (2 * (1 + nu))
lmbda = E * nu / ((1 + nu) * (1 - 2 * nu))
epsilon = 0.5 * (u_grad + u_grad.T)
return lmbda * np.trace(epsilon) * np.eye(3) + 2 * mu * epsilon
return stress_tensor
# Create mesh
meshio_mesh = box_mesh_gmsh(40, 20, 20, 2.0, 1.0, 1.0, data_dir='/tmp', ele_type='HEX8')
mesh = Mesh(meshio_mesh.points, meshio_mesh.cells_dict['hexahedron'])
# Set up problem
problem = LinearElasticity(mesh, vec=3, dim=3)
# Define boundary conditions using new API
def left_boundary(point):
return np.isclose(point[0], 0.0, atol=1e-5)
def right_boundary(point):
return np.isclose(point[0], 2.0, atol=1e-5)
bc_config = DirichletBCConfig([
# Fix left boundary completely (all components to zero)
DirichletBCSpec(left_boundary, 0, lambda p: 0.0),
DirichletBCSpec(left_boundary, 1, lambda p: 0.0),
DirichletBCSpec(left_boundary, 2, lambda p: 0.0),
# Apply tension on right boundary
DirichletBCSpec(right_boundary, 0, lambda p: 0.1)
])
# Create boundary conditions from config
bc = bc_config.create_bc(problem)
# Set up material properties
E_field = InternalVars.create_uniform_volume_var(problem, 70e3) # Young's modulus
internal_vars = InternalVars(volume_vars=(E_field,))
# Create solver
solver_options = SolverOptions(tol=1e-8, linear_solver="bicgstab")
solver = create_solver(problem, bc, solver_options)
# Solve
solution = solver(internal_vars)
print(f"Solution computed: displacement field shape {solution.shape}")
# Compute gradients
def compliance(internal_vars):
u = solver(internal_vars)
return np.sum(u**2)
grad_compliance = jax.grad(compliance)(internal_vars)
print(f"Gradient computed: {grad_compliance.volume_vars[0].shape}")
```
## Examples
### Linear Elasticity
- [**linear_elasticity.py**](examples/linear_elasticity.py): Linear elasticity with SIMP-based material interpolation
- [**linear_elasticity_vmap_density.py**](examples/linear_elasticity_vmap_density.py): Vectorized density-based material optimization
- [**linear_elasticity_vmap_traction.py**](examples/linear_elasticity_vmap_traction.py): Vectorized traction loading scenarios
### Other Physics
- [**poisson_2d.py**](examples/poisson_2d.py): 2D Poisson equation solver equivalent to JAX-FEM reference
## API Overview
### Core Components
#### Problem Definition
```python
class MyProblem(Problem):
def get_tensor_map(self):
# Define constitutive relationships
pass
def get_surface_maps(self):
# Define surface loads/tractions
pass
```
### Kernels for Weak Form Construction
FEAX uses kernels to construct weak forms for finite element analysis. These kernels implement the integral terms that arise from applying the Galerkin method to partial differential equations.
#### Supported Kernels
##### 1. Laplace Kernel (Diffusion/Elasticity)
The Laplace kernel handles gradient-based physics like heat conduction, diffusion, and elasticity:
$$\int_{\Omega} \sigma(\nabla u) : \nabla v \, d\Omega$$
where:
- $\sigma(\nabla u)$ is the stress/flux tensor computed from the gradient
- $v$ is the test function
- $:$ denotes tensor contraction
**Implementation**: Define `get_tensor_map()` returning a function that maps gradients to stress/flux tensors.
```python
def get_tensor_map(self):
def stress_tensor(u_grad, material_param):
# u_grad: (vec, dim) gradient tensor
# Returns: (vec, dim) stress/flux tensor
return compute_stress(u_grad, material_param)
return stress_tensor
```
##### 2. Mass Kernel (Inertia/Reaction)
The mass kernel handles terms without derivatives, used for inertia, reaction, or body forces:
$$\int_{\Omega} m(u, x) \cdot v \, d\Omega$$
where:
- $m(u, x)$ is a mass-like term (can depend on solution and position)
- $v$ is the test function
**Implementation**: Define `get_mass_map()` returning a function for the mass term.
```python
def get_mass_map(self):
def mass_map(u, x, density):
# u: (vec,) solution at quadrature point
# x: (dim,) physical coordinates
# Returns: (vec,) mass term
return density * acceleration_term(u)
return mass_map
```
##### 3. Surface Kernel (Boundary Loads)
Surface kernels handle boundary integrals for surface tractions, pressures, or fluxes:
$$\int_{\Gamma} t(u, x) \cdot v \, d\Gamma$$
where:
- $t(u, x)$ is the surface traction/flux
- $\Gamma$ is the boundary surface
**Implementation**: Define `get_surface_maps()` returning a list of surface functions.
```python
def get_surface_maps(self):
def surface_traction(u, x, traction_magnitude):
# u: (vec,) solution at surface quadrature point
# x: (dim,) surface coordinates
# Returns: (vec,) traction vector
return np.array([0., 0., traction_magnitude])
return [surface_traction] # List for multiple boundaries
```
##### 4. Universal Kernel (Custom Terms)
For complex physics that don't fit the above patterns, use universal kernels with full access to shape functions and quadrature data:
$$\int_{\Omega} f(u, \nabla u, x, N, \nabla N) \, d\Omega$$
**Implementation**: Define `get_universal_kernel()` for volume integrals or `get_universal_kernels_surface()` for surface integrals.
```python
def get_universal_kernel(self):
def universal_kernel(cell_sol_flat, x, shape_grads, JxW, v_grads_JxW, *params):
# Full access to FE data for custom weak forms
# cell_sol_flat: flattened solution on element
# x: quadrature points
# shape_grads: shape function gradients
# JxW: Jacobian times quadrature weights
# v_grads_JxW: test function gradients times JxW
return custom_weak_form_contribution
return universal_kernel
```
#### Kernel Composition
The total weak form is the sum of all kernel contributions:
$$R(u) = \int_{\Omega} \left[ \sigma(\nabla u) : \nabla v + m(u) \cdot v \right] d\Omega + \sum_i \int_{\Gamma_i} t_i(u) \cdot v \, d\Gamma_i$$
FEAX automatically:
1. Evaluates each kernel at quadrature points
2. Applies quadrature weights and Jacobians
3. Assembles contributions into the global residual
4. Computes the Jacobian matrix via automatic differentiation
#### Implementation Requirements
When implementing a Problem subclass:
1. **Laplace kernel** (`get_tensor_map`): Required for gradient-based physics
2. **Mass kernel** (`get_mass_map`): Optional, for mass/reaction terms
3. **Surface kernels** (`get_surface_maps`): Optional, returns list of boundary functions
4. **Universal kernels**: Optional, for complex custom physics
The kernels receive internal variables (material properties, loads) as additional arguments, enabling parameterization and differentiation.
#### Internal Variables
```python
# Material properties and loading parameters
internal_vars = InternalVars(
volume_vars=(young_modulus, density), # Element-wise properties
surface_vars=(surface_traction,) # Boundary-wise properties
)
```
#### Boundary Conditions
```python
# New boundary condition API using dataclasses
bc_config = DirichletBCConfig([
DirichletBCSpec(boundary_function, dof_index, value_function),
# Multiple boundary conditions
])
# Legacy API still available via DirichletBC.from_bc_info
bc = DirichletBC.from_bc_info(problem, [
[boundary_function], # Where to apply
[dof_index], # Which DOF
[value_function] # What value
])
```
#### Solvers
```python
# Newton solver for nonlinear problems
solution = newton_solve(J_func, res_func, initial_guess, options)
# Linear solver for linear problems
solution = linear_solve(J_func, res_func, initial_guess, options)
# Differentiable solver for optimization (recommended)
solver = create_solver(problem, bc, solver_options)
solution = solver(internal_vars)
```
## License
FEAX is licensed under the GNU General Public License v3.0. See [LICENSE](LICENSE) for the full license text.
## Acknowledgments
FEAX builds upon the excellent work of:
- [JAX](https://github.com/google/jax) for automatic differentiation and compilation
- [JAX-FEM](https://github.com/tianjuxue/jax_fem) for inspiration and reference implementations
---
*FEAX: Bringing modern automatic differentiation to finite element analysis.*
Raw data
{
"_id": null,
"home_page": null,
"name": "feax",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.9",
"maintainer_email": null,
"keywords": "JAX, CUDA, Simulation, PINN",
"author": "Naruki-Ichihara",
"author_email": "Naruki-Ichihara <ichihara.naruki@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/50/ab/d7ac565fd69f97b51c56722d9852bb7ed56cdf642f52914afbb6762263a0/feax-0.0.4.tar.gz",
"platform": null,
"description": "<div align=\"center\">\n<img src=\"assets/logo.svg\" alt=\"logo\" width=300></img>\n</div>\n\n# FEAX\n\n[](LICENSE)\n[](https://www.python.org/downloads/)\n[](https://github.com/google/jax)\n\n**FEAX** (Finite Element Analysis with JAX) is a compact, high-performance finite element analysis engine built on JAX. It provides an API for solving partial differential equations with automatic differentiation, JIT compilation, and GPU acceleration.\n\n## What is FEAX?\n\nFEAX combines the power of modern automatic differentiation with classical finite element methods. It's designed for:\n\n- **Differentiable Physics**: Compute gradients through entire FE simulations for optimization, inverse problems, and machine learning\n- **High Performance**: JIT compilation and vectorization through JAX for maximum computational efficiency\n\n## JAX Transformations in FEAX\n\n<div align=\"center\">\n<img src=\"assets/feax_jax_transformations.svg\" alt=\"JAX Transformations\" width=\"800\">\n</div>\n\nFEAX leverages JAX's powerful transformation system to enable:\n- **Automatic Differentiation**: Compute exact gradients through finite element solvers\n- **JIT Compilation**: Compile to optimized machine code for maximum performance \n- **Vectorization**: Efficiently process multiple scenarios in parallel with `vmap`\n- **Parallelization**: Scale across multiple devices with `pmap`\n\n## Installation\nUse pip to install:\n```bash\npip install feax\n```\n\nTo install the latest commit from the main branch:\n```bash\npip install git+https://github.com/Naruki-Ichihara/feax.git@main\n```\n\n## Key Features\n\n### Differentiable Solvers\n```python\nimport jax\nfrom feax import Problem, InternalVars, create_solver\n\n# Define your physics problem\nclass Elasticity(Problem):\n def get_tensor_map(self):\n def stress(u_grad, E):\n # Linear elasticity constitutive law\n return elastic_stress_tensor(u_grad, E)\n return stress\n\n# Create differentiable solver\nsolver = create_solver(problem, boundary_conditions, options)\n\n# Compute gradients with respect to material properties\ngrad_fn = jax.grad(lambda params: objective(solver(params)))\ngradients = grad_fn(material_parameters)\n```\n\n### Architecture\n```python\n# Separate problem definition from parameters\nproblem = ElasticityProblem(mesh, vec=3, dim=3)\ninternal_vars = InternalVars(\n volume_vars=(young_modulus, density),\n surface_vars=(surface_traction,)\n)\n\n# Solve with different parameter sets\nsolutions = jax.vmap(solver)(parameter_batch)\n```\n\n## Installation\n\n### Requirements\n- Python 3.10+\n- JAX 0.7+\n\n### Install from source\n```bash\ngit clone https://github.com/your-repo/feax.git\ncd feax\npip install -e .\n```\n\n## Quick Start\n\nHere's a simple linear elasticity example:\n\n```python\nimport jax\nimport jax.numpy as np\nfrom feax import Problem, InternalVars, create_solver\nfrom feax import Mesh, SolverOptions, zero_like_initial_guess\nfrom feax import DirichletBCSpec, DirichletBCConfig\nfrom feax.mesh import box_mesh_gmsh\n\n# Define the physics\nclass LinearElasticity(Problem):\n def get_tensor_map(self):\n def stress_tensor(u_grad, E):\n nu = 0.3 # Poisson's ratio\n mu = E / (2 * (1 + nu))\n lmbda = E * nu / ((1 + nu) * (1 - 2 * nu))\n epsilon = 0.5 * (u_grad + u_grad.T)\n return lmbda * np.trace(epsilon) * np.eye(3) + 2 * mu * epsilon\n return stress_tensor\n\n# Create mesh\nmeshio_mesh = box_mesh_gmsh(40, 20, 20, 2.0, 1.0, 1.0, data_dir='/tmp', ele_type='HEX8')\nmesh = Mesh(meshio_mesh.points, meshio_mesh.cells_dict['hexahedron'])\n\n# Set up problem\nproblem = LinearElasticity(mesh, vec=3, dim=3)\n\n# Define boundary conditions using new API\ndef left_boundary(point):\n return np.isclose(point[0], 0.0, atol=1e-5)\n\ndef right_boundary(point):\n return np.isclose(point[0], 2.0, atol=1e-5)\n\nbc_config = DirichletBCConfig([\n # Fix left boundary completely (all components to zero)\n DirichletBCSpec(left_boundary, 0, lambda p: 0.0),\n DirichletBCSpec(left_boundary, 1, lambda p: 0.0), \n DirichletBCSpec(left_boundary, 2, lambda p: 0.0),\n # Apply tension on right boundary\n DirichletBCSpec(right_boundary, 0, lambda p: 0.1)\n])\n\n# Create boundary conditions from config\nbc = bc_config.create_bc(problem)\n\n# Set up material properties\nE_field = InternalVars.create_uniform_volume_var(problem, 70e3) # Young's modulus\ninternal_vars = InternalVars(volume_vars=(E_field,))\n\n# Create solver\nsolver_options = SolverOptions(tol=1e-8, linear_solver=\"bicgstab\")\nsolver = create_solver(problem, bc, solver_options)\n\n# Solve\nsolution = solver(internal_vars)\nprint(f\"Solution computed: displacement field shape {solution.shape}\")\n\n# Compute gradients\ndef compliance(internal_vars):\n u = solver(internal_vars)\n return np.sum(u**2)\n\ngrad_compliance = jax.grad(compliance)(internal_vars)\nprint(f\"Gradient computed: {grad_compliance.volume_vars[0].shape}\")\n```\n\n## Examples\n\n### Linear Elasticity\n- [**linear_elasticity.py**](examples/linear_elasticity.py): Linear elasticity with SIMP-based material interpolation\n- [**linear_elasticity_vmap_density.py**](examples/linear_elasticity_vmap_density.py): Vectorized density-based material optimization\n- [**linear_elasticity_vmap_traction.py**](examples/linear_elasticity_vmap_traction.py): Vectorized traction loading scenarios\n\n### Other Physics\n- [**poisson_2d.py**](examples/poisson_2d.py): 2D Poisson equation solver equivalent to JAX-FEM reference\n\n## API Overview\n\n### Core Components\n\n#### Problem Definition\n```python\nclass MyProblem(Problem):\n def get_tensor_map(self):\n # Define constitutive relationships\n pass\n \n def get_surface_maps(self):\n # Define surface loads/tractions\n pass\n```\n\n### Kernels for Weak Form Construction\n\nFEAX uses kernels to construct weak forms for finite element analysis. These kernels implement the integral terms that arise from applying the Galerkin method to partial differential equations.\n\n#### Supported Kernels\n\n##### 1. Laplace Kernel (Diffusion/Elasticity)\nThe Laplace kernel handles gradient-based physics like heat conduction, diffusion, and elasticity:\n\n$$\\int_{\\Omega} \\sigma(\\nabla u) : \\nabla v \\, d\\Omega$$\n\nwhere:\n- $\\sigma(\\nabla u)$ is the stress/flux tensor computed from the gradient\n- $v$ is the test function\n- $:$ denotes tensor contraction\n\n**Implementation**: Define `get_tensor_map()` returning a function that maps gradients to stress/flux tensors.\n\n```python\ndef get_tensor_map(self):\n def stress_tensor(u_grad, material_param):\n # u_grad: (vec, dim) gradient tensor\n # Returns: (vec, dim) stress/flux tensor\n return compute_stress(u_grad, material_param)\n return stress_tensor\n```\n\n##### 2. Mass Kernel (Inertia/Reaction)\nThe mass kernel handles terms without derivatives, used for inertia, reaction, or body forces:\n\n$$\\int_{\\Omega} m(u, x) \\cdot v \\, d\\Omega$$\n\nwhere:\n- $m(u, x)$ is a mass-like term (can depend on solution and position)\n- $v$ is the test function\n\n**Implementation**: Define `get_mass_map()` returning a function for the mass term.\n\n```python\ndef get_mass_map(self):\n def mass_map(u, x, density):\n # u: (vec,) solution at quadrature point\n # x: (dim,) physical coordinates\n # Returns: (vec,) mass term\n return density * acceleration_term(u)\n return mass_map\n```\n\n##### 3. Surface Kernel (Boundary Loads)\nSurface kernels handle boundary integrals for surface tractions, pressures, or fluxes:\n\n$$\\int_{\\Gamma} t(u, x) \\cdot v \\, d\\Gamma$$\n\nwhere:\n- $t(u, x)$ is the surface traction/flux\n- $\\Gamma$ is the boundary surface\n\n**Implementation**: Define `get_surface_maps()` returning a list of surface functions.\n\n```python\ndef get_surface_maps(self):\n def surface_traction(u, x, traction_magnitude):\n # u: (vec,) solution at surface quadrature point\n # x: (dim,) surface coordinates\n # Returns: (vec,) traction vector\n return np.array([0., 0., traction_magnitude])\n return [surface_traction] # List for multiple boundaries\n```\n\n##### 4. Universal Kernel (Custom Terms)\nFor complex physics that don't fit the above patterns, use universal kernels with full access to shape functions and quadrature data:\n\n$$\\int_{\\Omega} f(u, \\nabla u, x, N, \\nabla N) \\, d\\Omega$$\n\n**Implementation**: Define `get_universal_kernel()` for volume integrals or `get_universal_kernels_surface()` for surface integrals.\n\n```python\ndef get_universal_kernel(self):\n def universal_kernel(cell_sol_flat, x, shape_grads, JxW, v_grads_JxW, *params):\n # Full access to FE data for custom weak forms\n # cell_sol_flat: flattened solution on element\n # x: quadrature points\n # shape_grads: shape function gradients\n # JxW: Jacobian times quadrature weights\n # v_grads_JxW: test function gradients times JxW\n return custom_weak_form_contribution\n return universal_kernel\n```\n\n#### Kernel Composition\n\nThe total weak form is the sum of all kernel contributions:\n\n$$R(u) = \\int_{\\Omega} \\left[ \\sigma(\\nabla u) : \\nabla v + m(u) \\cdot v \\right] d\\Omega + \\sum_i \\int_{\\Gamma_i} t_i(u) \\cdot v \\, d\\Gamma_i$$\n\nFEAX automatically:\n1. Evaluates each kernel at quadrature points\n2. Applies quadrature weights and Jacobians\n3. Assembles contributions into the global residual\n4. Computes the Jacobian matrix via automatic differentiation\n\n#### Implementation Requirements\n\nWhen implementing a Problem subclass:\n\n1. **Laplace kernel** (`get_tensor_map`): Required for gradient-based physics\n2. **Mass kernel** (`get_mass_map`): Optional, for mass/reaction terms\n3. **Surface kernels** (`get_surface_maps`): Optional, returns list of boundary functions\n4. **Universal kernels**: Optional, for complex custom physics\n\nThe kernels receive internal variables (material properties, loads) as additional arguments, enabling parameterization and differentiation.\n\n#### Internal Variables\n```python\n# Material properties and loading parameters\ninternal_vars = InternalVars(\n volume_vars=(young_modulus, density), # Element-wise properties\n surface_vars=(surface_traction,) # Boundary-wise properties\n)\n```\n\n#### Boundary Conditions\n```python\n# New boundary condition API using dataclasses\nbc_config = DirichletBCConfig([\n DirichletBCSpec(boundary_function, dof_index, value_function),\n # Multiple boundary conditions\n])\n\n# Legacy API still available via DirichletBC.from_bc_info\nbc = DirichletBC.from_bc_info(problem, [\n [boundary_function], # Where to apply\n [dof_index], # Which DOF\n [value_function] # What value\n])\n```\n\n#### Solvers\n```python\n# Newton solver for nonlinear problems\nsolution = newton_solve(J_func, res_func, initial_guess, options)\n\n# Linear solver for linear problems\nsolution = linear_solve(J_func, res_func, initial_guess, options)\n\n# Differentiable solver for optimization (recommended)\nsolver = create_solver(problem, bc, solver_options)\nsolution = solver(internal_vars)\n```\n\n## License\n\nFEAX is licensed under the GNU General Public License v3.0. See [LICENSE](LICENSE) for the full license text.\n\n## Acknowledgments\n\nFEAX builds upon the excellent work of:\n- [JAX](https://github.com/google/jax) for automatic differentiation and compilation\n- [JAX-FEM](https://github.com/tianjuxue/jax_fem) for inspiration and reference implementations\n\n---\n\n*FEAX: Bringing modern automatic differentiation to finite element analysis.*\n",
"bugtrack_url": null,
"license": null,
"summary": "A GPU-accelerated finite element analysis framework with JAX.",
"version": "0.0.4",
"project_urls": null,
"split_keywords": [
"jax",
" cuda",
" simulation",
" pinn"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "508edbed19d5a677b3ecfe6d22153564304040923ab1c56790d6d566675de0ff",
"md5": "192ed11a6b6e8bce5c9e78b17edcef3a",
"sha256": "fdb0179b52a61a32ccf9c07401aa0aceae08cd2bacd43759006383c09f31ed16"
},
"downloads": -1,
"filename": "feax-0.0.4-py3-none-any.whl",
"has_sig": false,
"md5_digest": "192ed11a6b6e8bce5c9e78b17edcef3a",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.9",
"size": 55483,
"upload_time": "2025-08-18T05:47:25",
"upload_time_iso_8601": "2025-08-18T05:47:25.006479Z",
"url": "https://files.pythonhosted.org/packages/50/8e/dbed19d5a677b3ecfe6d22153564304040923ab1c56790d6d566675de0ff/feax-0.0.4-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "50abd7ac565fd69f97b51c56722d9852bb7ed56cdf642f52914afbb6762263a0",
"md5": "5ff60091d36ee95bfc3f1154c221f475",
"sha256": "d68848357834428af7a1e7065b7e50cb0e806db49368c22e14c6a890a0f20027"
},
"downloads": -1,
"filename": "feax-0.0.4.tar.gz",
"has_sig": false,
"md5_digest": "5ff60091d36ee95bfc3f1154c221f475",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.9",
"size": 54015,
"upload_time": "2025-08-18T05:47:26",
"upload_time_iso_8601": "2025-08-18T05:47:26.517274Z",
"url": "https://files.pythonhosted.org/packages/50/ab/d7ac565fd69f97b51c56722d9852bb7ed56cdf642f52914afbb6762263a0/feax-0.0.4.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-08-18 05:47:26",
"github": false,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"lcname": "feax"
}
