kerf-multikernel 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,382 @@
1
+ Metadata-Version: 2.1
2
+ Name: kerf-multikernel
3
+ Version: 0.1.0
4
+ Summary: Multikernel Management CLI tool
5
+ Author: Cong Wang
6
+ Requires-Python: >=3.9,<4.0
7
+ Classifier: Programming Language :: Python :: 3
8
+ Classifier: Programming Language :: Python :: 3.9
9
+ Classifier: Programming Language :: Python :: 3.10
10
+ Classifier: Programming Language :: Python :: 3.11
11
+ Classifier: Programming Language :: Python :: 3.12
12
+ Classifier: Programming Language :: Python :: 3.13
13
+ Requires-Dist: click (>=8.0.0,<9.0.0)
14
+ Requires-Dist: pylibfdt (>=1.7.0,<2.0.0)
15
+ Requires-Dist: pyudev (>=0.24.0,<0.25.0)
16
+ Requires-Dist: pyyaml (>=6.0,<7.0)
17
+ Requires-Dist: rdtsc (>=0.2.1,<0.3.0)
18
+ Description-Content-Type: text/markdown
19
+
20
+ ![Kerf Logo](logo.png)
21
+
22
+ # Kerf: Multikernel Management System
23
+
24
+ ## Overview
25
+
26
+ `kerf` is a comprehensive multikernel management system designed to orchestrate and manage multiple kernel instances on a single host. Starting with advanced device tree compilation and validation, `kerf` provides the foundation for complete multikernel lifecycle management.
27
+
28
+ Unlike standard tools that only perform basic format conversion, `kerf` understands multikernel semantics and **always validates** resource allocations and detects conflicts. The system is architected to evolve into a complete multikernel runtime environment.
29
+
30
+ ## Features
31
+
32
+ `kerf` is a comprehensive multikernel management platform with the following capabilities:
33
+
34
+ - **Resource Pool Initialization**: Initialize hardware resource pools available for multikernel allocation
35
+ - **Resource Conflict Detection**: Detect and prevent allocation conflicts for CPUs, memory regions, and devices
36
+ - **Resource Validation**: Ensure allocations don't exceed available resources and references are valid
37
+ - **Atomicity**: Validate all allocations together before deployment
38
+ - **Kernel Loading & Execution**: Load and execute multiple kernel instances with proper isolation
39
+ - **Instance Lifecycle**: Create, delete, and manage kernel instances
40
+ - **Dynamic Resource Management**: Allocation and deallocation of system resources
41
+ - **Monitoring & Debugging**: Real-time monitoring of kernel instances and system health
42
+ - **Security & Isolation**: Advanced security policies and isolation mechanisms
43
+ - **Orchestration**: High-level orchestration of complex multikernel workloads
44
+
45
+ ## Architecture
46
+
47
+ ### Design Philosophy
48
+
49
+ The `kerf` system is built on foundational principles that support both current resource pool management and future multikernel runtime features:
50
+
51
+ 1. **Single Source of Truth**: Baseline DTS describes hardware resources available for allocation
52
+ 2. **Mandatory Validation**: Every operation validates the configuration - validation is not optional
53
+ 3. **Fail-Fast**: Catch resource conflicts immediately, never produce invalid output
54
+ 4. **Overlay-based Management**: Dynamic instance changes are managed via device tree overlays
55
+ 5. **Extensible Architecture**: Designed to support future kernel loading, execution, and management capabilities
56
+ 6. **Developer-Friendly**: Clear error messages with suggestions for fixing problems
57
+ 7. **Runtime-Ready**: Current design anticipates future kernel execution and lifecycle management needs
58
+
59
+ ### Compilation Model
60
+
61
+ **Resource pool initialization:**
62
+ ```
63
+ Input: Baseline DTS (resources only)
64
+ │
65
+ ▼
66
+ ┌─────────┐
67
+ │ kerf │ ← Initializes resource pool
68
+ │ init │ and validates
69
+ └─────────┘
70
+ │
71
+ ▼
72
+ Baseline DTB
73
+ (resources only)
74
+ → /sys/fs/multikernel/device_tree
75
+ ```
76
+
77
+ **Overlay-based dynamic changes:**
78
+ ```
79
+ Current State Modified State
80
+ (Baseline + Overlays) (After change)
81
+ │ │
82
+ ├───────────────────────┤
83
+ │ │
84
+ ▼ ▼
85
+ ┌─────────┐ ┌─────────┐
86
+ │ Compute │ │ Compute │
87
+ │ Delta │ │ Delta │
88
+ └─────────┘ └─────────┘
89
+ │ │
90
+ └───────────┬───────────┘
91
+ │
92
+ ▼
93
+ ┌─────────────┐
94
+ │ kerf │ ← Validates full state
95
+ │ (create/ │ before generating overlay
96
+ │ update/ │
97
+ │ delete) │
98
+ └─────────────┘
99
+ │
100
+ ▼
101
+ DTBO Overlay
102
+ │
103
+ ▼
104
+ → /sys/fs/multikernel/overlays/new
105
+ │
106
+ ▼
107
+ Applied Overlay
108
+ → /sys/fs/multikernel/overlays/tx_XXX/
109
+ ```
110
+
111
+ **Complete system state:**
112
+ ```
113
+ Baseline DTB (static)
114
+ │
115
+ ├─── Overlay tx_101 (instance: web-server)
116
+ ├─── Overlay tx_102 (instance: database)
117
+ └─── Overlay tx_103 (update: web-server resources)
118
+ │
119
+ ▼
120
+ Effective Device Tree
121
+ (Baseline + All Applied Overlays)
122
+ │
123
+ ▼
124
+ Kernel Instance Views
125
+ /sys/fs/multikernel/instances/*
126
+ ```
127
+
128
+ **Key Points:**
129
+ - **Baseline contains only resources**: Hardware resources available for allocation, loaded once via `kerf init`
130
+ - **Instances created via overlays**: Dynamic instance lifecycle managed through device tree overlays (DTBO)
131
+ - **Overlay generation**: Computes delta between current and modified state, generates minimal DTBO
132
+ - **Transactional overlays**: Each overlay is a transaction with rollback support via `rmdir`
133
+ - **Validation is mandatory**: Always validates full state (baseline + all overlays) before applying
134
+ - **Single source of truth**: Baseline DTB is the authoritative resource configuration, overlays add instances dynamically
135
+
136
+ ## Current Capabilities
137
+
138
+ ### Resource Pool Management & Validation
139
+ - **Resource Pool Initialization**: Initialize hardware resource pools for multikernel allocation
140
+ - **Advanced Validation**: Comprehensive resource conflict detection and validation
141
+ - **Baseline Management**: Initialize and manage baseline device tree containing hardware resources
142
+ - **Format Support**: DTS to DTB compilation for baseline configuration
143
+ - **Error Reporting**: Detailed error messages with actionable suggestions
144
+ - **Resource Analysis**: Complete resource utilization reporting
145
+ - **CPU & NUMA Topology**: Full support for CPU topology and NUMA-aware resource allocation
146
+
147
+ ### Command Line Interface
148
+ ```bash
149
+ # Initialize resource pool with CPUs (memory parsed from /proc/iomem)
150
+ kerf init --cpus=4-7
151
+
152
+ # Initialize with CPUs and devices
153
+ kerf init --cpus=4-31 --devices=enp9s0_dev,nvme0
154
+
155
+ # Create kernel instance with resource allocation
156
+ kerf create web-server --cpus=4-7 --memory=2GB
157
+ kerf create database --cpu-count=8 --memory=16GB
158
+
159
+ # Load kernel image with initrd and boot parameters
160
+ kerf load --kernel=/boot/vmlinuz --initrd=/boot/initrd.img \
161
+ --cmdline="root=/dev/sda1 ro" --id=1
162
+
163
+ # Boot a kernel instance
164
+ kerf exec web-server
165
+
166
+ # Show kernel instance information
167
+ kerf show
168
+ kerf show web-server
169
+
170
+ # Shutdown a running kernel instance
171
+ kerf kill web-server
172
+
173
+ # Unload kernel image from an instance
174
+ kerf unload web-server
175
+
176
+ # Delete a kernel instance
177
+ kerf delete web-server
178
+
179
+ # Use --help for detailed options and usage
180
+ kerf --help
181
+ kerf <command> --help
182
+ ```
183
+
184
+ ### Technical Foundation
185
+ The current resource pool management provides essential building blocks for future multikernel capabilities:
186
+
187
+ - **Resource Pool Initialization**: Initializes hardware resource pools for safe multikernel allocation
188
+ - **Resource Validation**: Ensures safe resource allocation before kernel execution
189
+ - **Instance Isolation**: Provides the foundation for secure kernel isolation
190
+ - **Configuration Management**: Enables consistent and validated system configurations
191
+ - **Error Handling**: Establishes patterns for robust error reporting and recovery
192
+ - **Extensible Architecture**: Designed to support future kernel management APIs
193
+
194
+ These foundational capabilities are essential for safe and reliable multikernel execution, making `kerf` the ideal platform for building comprehensive multikernel management systems.
195
+
196
+
197
+ ## Global Device Tree Format
198
+
199
+ ### Structure Overview
200
+
201
+ The baseline device tree contains only the **Resources** section, which describes all physical hardware available for allocation. Instances and device references are added dynamically via overlays when using `kerf create`.
202
+
203
+ 1. **Resources** (`/resources`): Complete description of all physical resources (baseline only)
204
+ 2. **Instances** (`/instances`): Resource assignments for each spawn kernel (added via overlays)
205
+ 3. **Device References**: Linkage between instances and hardware devices (added via overlays)
206
+
207
+ ### Baseline Example
208
+
209
+ The baseline contains hardware resources used for allocation. Resources are typically passed via command line arguments during the `kerf init` command. Instances are created dynamically via overlays using `kerf create`.
210
+
211
+ ### Mapping to Kernel Filesystem Interface
212
+
213
+ **Device Tree Structure → Kernel Filesystem Interface:**
214
+
215
+ ```
216
+ DTS: /resources → /sys/kernel/multikernel/device_tree (writable, single source of truth)
217
+ DTS: /instances/web-server → /sys/kernel/multikernelinstances/web-server/ (read-only)
218
+ DTS: /instances/database → /sys/kernel/multikernel/instances/database/ (read-only)
219
+ DTS: /instances/compute → /sys/kernel/multikernel/instances/compute/ (read-only)
220
+ ```
221
+
222
+ **Name-based addressing:**
223
+ - Instance node name in DTS (`web-server`) = directory name in kernel filesystem (`instances/web-server/`)
224
+ - Kernel assigns numeric IDs, but users reference by name
225
+ - No manual ID coordination needed
226
+ - Instance directories are auto-generated by the kernel from the global device tree
227
+
228
+ ## Validation Rules
229
+
230
+ ### Validation is Mandatory
231
+
232
+ **All `kerf` operations perform validation automatically:**
233
+ - Compiling DTS to DTB → validates
234
+ - Converting formats → validates
235
+ - Generating reports → validates first
236
+
237
+ **Validation cannot be disabled or skipped.**
238
+
239
+ ### CPU Allocation Validation
240
+
241
+ **Rules:**
242
+ 1. CPUs must be defined in the baseline resource pool
243
+ 2. No CPU can be allocated to multiple instances
244
+ 3. CPU lists should be explicitly enumerated
245
+
246
+ ### Memory Allocation Validation
247
+
248
+ **Rules:**
249
+ 1. Memory regions must be within the baseline memory pool
250
+ 2. Memory regions cannot overlap between instances
251
+ 3. Sum of all allocations must not exceed baseline memory pool size
252
+ 4. Memory base addresses must be page-aligned (4KB = 0x1000)
253
+
254
+
255
+ ### Device Allocation Validation
256
+
257
+ **Rules:**
258
+ 1. Referenced devices must be defined in the baseline
259
+ 2. Devices can only be allocated to one instance (exclusive access)
260
+ 3. Device references must be valid (no dangling phandles)
261
+ 4. SR-IOV VF numbers must be within device limits
262
+ 5. Namespace IDs must be within device limits
263
+
264
+ ### Global Resource Validation
265
+
266
+ **Rules:**
267
+ 1. Instance names must be unique
268
+ 2. All phandle references must resolve
269
+ 3. Baseline resource configuration must be complete and consistent
270
+
271
+
272
+ ## Integration with Kernel
273
+
274
+ ### Kernel Interface
275
+
276
+ The kernel exposes a filesystem interface (mounted at `/sys/fs/multikernel/`) that manages baseline resources and overlay-based instance changes:
277
+
278
+ **Kernel Interface Structure:**
279
+ ```
280
+ /sys/fs/multikernel/
281
+ ├── device_tree # Baseline DTB (resources only, writable via kerf init)
282
+ ├── overlays/ # Overlay subsystem
283
+ │ ├── new # Write DTBO here to apply overlay
284
+ │ ├── tx_101/ # Applied overlay transaction
285
+ │ │ ├── id # Transaction ID: "101"
286
+ │ │ ├── status # "applied" | "failed" | "removed"
287
+ │ │ ├── dtbo # Original overlay blob (binary)
288
+ │ │ └── ...
289
+ │ └── tx_102/
290
+ │ └── ...
291
+ └── instances/ # Runtime kernel instances (read-only)
292
+ ├── web-server/
293
+ │ ├── id # Instance ID
294
+ │ ├── status # Instance status
295
+ │ └── ...
296
+ └── ...
297
+ ```
298
+
299
+ **Key Design Principles:**
300
+ - **Baseline Separation**: Baseline (`device_tree`) contains only resources - no instances
301
+ - **Overlay-based Changes**: All dynamic changes (create, update, delete instances) via overlays
302
+ - **Rollback Support**: Remove overlay transaction directory (`rmdir /sys/fs/multikernel/overlays/tx_XXX/`) to rollback changes
303
+ - **Kernel-Generated**: Instance directories auto-generated from baseline + applied overlays
304
+
305
+
306
+ ## Dependencies
307
+
308
+ ### Required Dependencies
309
+
310
+ ```toml
311
+ [tool.poetry.dependencies]
312
+ python = "^3.8"
313
+ pylibfdt = "^1.7.0" # Device tree parsing (from dtc project)
314
+ ```
315
+
316
+ ### Installation
317
+
318
+ ```bash
319
+ # From PyPI (the distribution is named kerf-multikernel;
320
+ # the installed command is still 'kerf')
321
+ pip install kerf-multikernel
322
+
323
+ # Or isolated with pipx, avoiding conflicts with other packages
324
+ pipx install kerf-multikernel
325
+
326
+ # From source (recommended for development)
327
+ git clone https://github.com/multikernel/kerf.git
328
+ cd kerf
329
+ # Installs 'kerf' command to ~/.local/bin/kerf
330
+ pip install -e .
331
+
332
+ # Installs 'kerf' command to the system Python's scripts directory
333
+ # (typically /usr/local/bin/kerf, or /usr/bin/kerf if using system Python)
334
+ sudo pip install .
335
+
336
+ ```
337
+
338
+ ### Getting Started
339
+
340
+ ```bash
341
+ # Install in development mode
342
+ pip install -e .
343
+
344
+ # Test the installation
345
+ kerf --help
346
+ kerf init --help
347
+
348
+ # Try with example baseline configuration
349
+ kerf init --input=examples/baseline.dts --report
350
+ ```
351
+
352
+ ## Examples
353
+
354
+ The `examples/` directory contains sample baseline Device Tree Source (DTS) files demonstrating various hardware resource configurations:
355
+
356
+ - **`baseline.dts`** - Complete baseline with CPU, memory, and device resources (32 CPUs, 16GB memory)
357
+ - **`minimal.dts`** - Simple baseline for testing and development (8 CPUs, 8GB memory)
358
+ - **`edge_computing.dts`** - Edge computing baseline with GPU support for AI inference (16 CPUs, 32GB memory)
359
+ - **`numa_topology.dts`** - Advanced NUMA topology baseline with 4 NUMA nodes and topology-aware allocation
360
+ - **`system.dts`** - Example baseline with various device configurations
361
+ - **`conflict_example.dts`** - Intentionally invalid baseline demonstrating common validation errors
362
+
363
+ **Note**: All baseline files contain **only** hardware resources - no instances. Instances are created dynamically via overlays using `kerf create` command.
364
+
365
+ ## CPU and NUMA Topology Support
366
+
367
+ Kerf provides comprehensive support for CPU and NUMA topology management:
368
+
369
+ ### Key Features
370
+ - **CPU Topology**: Socket, core, and thread mapping with SMT/hyperthreading support
371
+ - **NUMA Awareness**: NUMA node definition with memory regions and CPU assignments
372
+ - **Topology Policies**: CPU affinity (`compact`, `spread`, `local`) and memory policies (`local`, `interleave`, `bind`)
373
+ - **Performance Validation**: Automatic validation of topology constraints and performance warnings
374
+
375
+ For detailed information about CPU and NUMA topology support, see [CPU_NUMA_TOPOLOGY.md](docs/CPU_NUMA_TOPOLOGY.md).
376
+
377
+ ## References
378
+
379
+ - **Device Tree Specification**: https://devicetree-specification.readthedocs.io/
380
+ - **libfdt Documentation**: https://git.kernel.org/pub/scm/utils/dtc/dtc.git/tree/Documentation
381
+
382
+
@@ -0,0 +1,49 @@
1
+ kerf/__init__.py,sha256=gzj2kQn9rUBotjKJcW958f-z_jD99BH0p3pDUp8Pmkk,2047
2
+ kerf/baseline.py,sha256=P_bVvq1Zg9OcBGK2S1u_91ivdUWwyYWjAg6yis8j3Qo,6986
3
+ kerf/cli.py,sha256=X1KEk1GrfX0uXJEi-WoEtU5ThbjogXBlzZZKM8jvrVc,1579
4
+ kerf/console/__init__.py,sha256=IFML1PZYlqsbxWojVtp7V_J-pupgcAboAiPt1EYLclY,727
5
+ kerf/console/main.py,sha256=YibQldaGqJJo228DtPqYDYQSieO6R_OCV_adZmzaPaU,9249
6
+ kerf/create/__init__.py,sha256=J90J4xphuGgCYOplX0k9ijwieIxOtohgFhOqUM7hskM,635
7
+ kerf/create/main.py,sha256=GvFm7JLEsR9JNFXZgUmyb4FfNVsJ9sE9lRqDapHPux8,29227
8
+ kerf/data/__init__.py,sha256=kvt_lTupWz5WEO7c1ACqfcj3VNum3m8E-V3KNng-iSQ,869
9
+ kerf/data/kerf-init,sha256=Kvrtb91QGXC8jZiNx0tE7kOSYV8Cjq6BWR5If_0VsbE,53664
10
+ kerf/daxfs/__init__.py,sha256=4oYVG57nXEhRxZmvxU4VHByXpFG1kFpDq5o8SKhROQ4,895
11
+ kerf/daxfs/mkdaxfs.py,sha256=6y8E9cIryfegY0IbKteNAhGJG1m2aNVBma3EyB_Ywdw,20536
12
+ kerf/delete/__init__.py,sha256=tA4P042jfJb38zxKWWRHijfNBax2fd1yKfpFG4ZCHrM,701
13
+ kerf/delete/main.py,sha256=oiEAHuhc-425EHhjJHRz6OlCsnAc2YhuMxJBT2Egag8,9246
14
+ kerf/docker/__init__.py,sha256=Qgjxyl7OkR8l4n2ZILITqRP-lTQ5ElRtJymHP0jdGTk,753
15
+ kerf/docker/image.py,sha256=eaV7yonY01OTcGwRPYHdO33AIYtMl_mWARt9_NZSKgE,8538
16
+ kerf/dtc/__init__.py,sha256=bsljI90hkEgbJYxYSSk7Msn6h8qCV983CuEywxppQBI,1015
17
+ kerf/dtc/cells.py,sha256=gzsBINKXA79gq9avHDegF6pwvxG932z3YltUvGYTLFw,1910
18
+ kerf/dtc/extractor.py,sha256=p6rq-JRDcOo_TVY9owwco1MgqLod_A0xgFmVYyQiVMs,15308
19
+ kerf/dtc/overlay.py,sha256=XOXXiRdpIYEdLjXCd7yZ6oHjv8QHiT5BNEiXuK1illk,14208
20
+ kerf/dtc/parser.py,sha256=Cz3sdPG1jnsdG6irT8dGNvCjNKzknf7s8hdX8nCzDrg,58033
21
+ kerf/dtc/reporter.py,sha256=_ILKz0Dlm9RU630NTErptWYodj8q7_GebjZ5QvhR1Zg,11805
22
+ kerf/dtc/validator.py,sha256=cOKtQq8sUrX-GyJrhC1X4u8PEFxgt9vjRPz4auuWrXk,36174
23
+ kerf/exceptions.py,sha256=TjVbFL0uy5-RjiETMsyO0qU7N32PpV7MwfKXRIhWqQk,1394
24
+ kerf/exec/__init__.py,sha256=i7QGRRFGgBDdiwPdgSg2-MgqA74Kx532HVbFv-bCkMM,699
25
+ kerf/exec/main.py,sha256=hS03iNvV19roWWcyeabb4L9FFDLFGUZ4VcUP9OEIwTc,9392
26
+ kerf/init/__init__.py,sha256=_kDI54xEhI5qpZBK1RGrEMAXu4cTtLlkWhGaFrdVfY4,594
27
+ kerf/init/main.py,sha256=LHUCoAl1wINIY068MHpTiMEHuwrfcGvAAD64O_RWaTo,26702
28
+ kerf/kill/__init__.py,sha256=K4WFTu70RdptWw2rDmA3HJo3SVcB4iv9JqE4N--mCJA,698
29
+ kerf/kill/main.py,sha256=wIDZs9xK_EhUhHeCwDFVQFhbhwATWd1MN-Pu0-m-otc,9172
30
+ kerf/lazy_cma.py,sha256=3ZFpd5jFJCRCyww5JKbqcjdcbOP3FmJrFhvl6pHgC-E,4311
31
+ kerf/load/__init__.py,sha256=Yys--zl-Pvi0uPjDo-9dnpkIgvovqvg90LDzy3_FIvY,689
32
+ kerf/load/main.py,sha256=32XtwEBxP98FxHwcs7v2XEOtUJDTyzHE_Cya83ZND60,23399
33
+ kerf/metadata.py,sha256=E3EvQ_kRtl-Pv9Q4y9zAfNcrSwxW0HC4In5rg2cTI2k,4010
34
+ kerf/models.py,sha256=C3eA9yy6KXALA_4jiUdi_qK9ineCgbZPnFHTJuERDgU,6642
35
+ kerf/resources.py,sha256=vhQ727ZZSmDEl0Mh32f3KmOIE23SPpfGkrkWndUefjA,12307
36
+ kerf/runtime.py,sha256=PXKjV7BbugSq5KG5C1HUoA1mnY8Lg9A26Z_IePg-WPM,19473
37
+ kerf/show/__init__.py,sha256=8JPIUTqJYbdCwzjZKXnOTqpiBvawzoPJeVtoJwN67Ak,703
38
+ kerf/show/main.py,sha256=38oJ1qOcLiYStcyvyDGyx006poWnwizTURFfgDmZFnI,22360
39
+ kerf/unload/__init__.py,sha256=NzDx2_QHHvpTZ3MYsogAbrfRoENqZwwlvA0UsgyJy6k,695
40
+ kerf/unload/main.py,sha256=m9WJLURI9kzTrLb16HYZBZkbwnMYTwYoiLlzFlvePEQ,11833
41
+ kerf/update/__init__.py,sha256=5mCcFr07VslccVcW9Kh_O3LtQdSeLPrO53INJ9ygRC8,635
42
+ kerf/update/main.py,sha256=KP7WFGm8X03v5hmXgbtsKT57fdREG5jwTmRgWzckLXU,19120
43
+ kerf/utils.py,sha256=21SFo3T5J5M14zW-X0QeqAIIzNV9KtF_IliVHfKgqmM,2629
44
+ kerf/vmlinuz.py,sha256=7i_wcXVJqjkcoWpSs_RxGRjlwJzWXG3o1d8A2Bhj-NE,7175
45
+ kerf_multikernel-0.1.0.dist-info/LICENSE,sha256=vJmVELU587N5GaZO-Ouk0QHt0EGpkJYjEWTSbKpvdW0,11360
46
+ kerf_multikernel-0.1.0.dist-info/METADATA,sha256=Bs3mlX4bWIs2PK5PEy089zqqZ5n-bn0qXU7NBIx6lQM,15577
47
+ kerf_multikernel-0.1.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
48
+ kerf_multikernel-0.1.0.dist-info/entry_points.txt,sha256=FZdHjq6Wi30NLjOXQbCUaik1WQMmyWJPzV1klVogZtg,38
49
+ kerf_multikernel-0.1.0.dist-info/RECORD,,
@@ -0,0 +1,4 @@
1
+ Wheel-Version: 1.0
2
+ Generator: poetry-core 1.9.1
3
+ Root-Is-Purelib: true
4
+ Tag: py3-none-any
@@ -0,0 +1,3 @@
1
+ [console_scripts]
2
+ kerf=kerf.cli:main
3
+