# knitout-interpreter
[](https://pypi.org/project/knitout-interpreter)
[](https://pypi.org/project/knitout-interpreter)
[](https://opensource.org/licenses/MIT)
[](https://mypy-lang.org/)
[](https://github.com/pre-commit/pre-commit)
A comprehensive Python library for interpreting and executing knitout files used to control automatic V-Bed knitting machines.
This library provides full support for the [Knitout specification](https://textiles-lab.github.io/knitout/knitout.html) created by McCann et al.,
enabling programmatic knitting pattern analysis, validation, and execution simulation.
## 📑 Table of Contents
- [🧶 Overview](#-overview)
- [🚀 Key Features](#-key-features)
- [📦 Installation](#-installation)
- [📚 Core Components](#-core-components)
- [Knitout Executer](#knitout-executer)
- [Instruction Types](#instruction-types)
- [Carriage Pass Organization](#carriage-pass-organization)
- [📖 Examples](#-examples)
- [📋 Dependencies](#-dependencies)
- [📄 License](#-license)
- [🙏 Acknowledgments](#-acknowledgments)
- [📚 Related Projects](#-related-projects)
- [🔗 Links](#-links)
## 🧶 Overview
The knitout-interpreter bridges the gap between high-level knitting pattern descriptions and machine-level execution. It provides tools for:
- **Parsing** knitout files into structured Python objects
- **Validating** knitting instructions against common errors
- **Simulating** execution on virtual knitting machines
- **Analyzing** patterns for timing, width requirements, and complexity
- **Reorganizing** instructions for optimal machine execution
## 🚀 Key Features
### Core Functionality
- ✅ Full compliance with Knitout specification v2
- ✅ Support for all needle operations (knit, tuck, split, drop, xfer, miss, kick)
- ✅ Carrier management (in, out, inhook, outhook, releasehook)
- ✅ Racking and positioning controls
- ✅ Header processing (machine, gauge, yarn, carriers, position)
### Advanced Analysis
- 📊 **Execution Time Analysis**: Measure knitting time in carriage passes
- 📏 **Width Calculation**: Determine required needle bed width
- 🔍 **Error Detection**: Identify common knitting errors before execution
- 📈 **Knit Graph Generation**: Create structured representations of the final fabric
### Virtual Machine Integration
- 🖥️ Built on the [virtual-knitting-machine](https://pypi.org/project/virtual-knitting-machine/) library
- 🧠 Maintains complete machine state during execution
- 📋 Tracks loop creation, movement, and removal from the machine bed
- ⚠️ Provides detailed warnings for potential issues
## 📦 Installation
### From PyPI (Recommended)
```bash
pip install knitout-interpreter
```
### From Source
```bash
git clone https://github.com/mhofmann-Khoury/knitout_interpreter.git
cd knitout_interpreter
pip install -e .
```
### Development Installation
```bash
git clone https://github.com/mhofmann-Khoury/knitout_interpreter.git
cd knitout_interpreter
pip install -e ".[dev]"
pre-commit install
```
### From Test-PyPi
If you wish to install an unstable release from test-PyPi, note that this will have dependencies on PyPi repository.
Use the following command to gather those dependencies during install.
```bash
pip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ knitout-interpreter
```
## 🏃♂️ Quick Start
### Basic Usage
```python
"""Example Run of Knitout processed into instruction, final machine state, and resulting knit_graph"""
from knitout_interpreter.run_knitout import run_knitout
# Parse and execute a knitout file
instructions, machine, knit_graph = run_knitout("pattern.k")
print(f"Executed {len(instructions)} instructions")
```
### Advanced Analysis with Knitout Executer
```python
""" Example of parsing knitout lines from the knitout parser and organizing the executed instructions with the Knitout Executer."""
from knitout_interpreter.knitout_execution import Knitout_Executer
from knitout_interpreter.knitout_language.Knitout_Parser import parse_knitout
from virtual_knitting_machine.Knitting_Machine import Knitting_Machine
# Parse knitout file
instructions = parse_knitout("complex_pattern.k", pattern_is_file=True)
# Execute with analysis
executer = Knitout_Executer(instructions, Knitting_Machine())
# Get execution metrics
print(f"Execution time: {executer.execution_time} carriage passes")
print(f"Width required: {executer.left_most_position} to {executer.right_most_position}")
# Save reorganized instructions
executer.write_executed_instructions("executed_pattern.k")
```
## 📚 Core Components
### Knitout Executer
The main analysis class that provides comprehensive execution simulation:
```python
"""Example of loading a fully specified Knitout Executer"""
from knitout_interpreter.knitout_execution import Knitout_Executer
from knitout_interpreter.knitout_language.Knitout_Parser import parse_knitout
from virtual_knitting_machine.Knitting_Machine import Knitting_Machine
# Parse knitout file
parsed_instructions = parse_knitout("example.k", pattern_is_file=True)
executer = Knitout_Executer(
instructions=parsed_instructions,
knitting_machine=Knitting_Machine(),
accepted_error_types=[], # Optional: Knitting Machine Errors to ignore
knitout_version=2
)
```
**Key Properties:**
- `execution_time`: Number of carriage passes that will be executed
- `left_most_position` / `right_most_position`: The range of needle positions in the executed file.
- `carriage_passes`: List of carriage passes in the order they are executed.
- `resulting_knit_graph`: Final fabric structure
### Instruction Types
The library supports all knitout operations as Python classes:
#### Needle Operations
- `Knit_Instruction`: Create new loops, stitch through the old one.
- `Tuck_Instruction`: Create new loops, keeping old ones.
- `Split_Instruction`: Creates a loop on first specified needle while moving existing loops to the second specified needle.
- `Drop_Instruction`: Remove loops from needles
- `Xfer_Instruction`: Transfer loops between needles
- `Miss_Instruction`: Position carriers without forming loops
- `Kick_Instruction`: Specialized miss for kickbacks
#### Carrier Operations
- `In_Instruction` / `Out_Instruction`: Move carriers in/out of knitting area
- `Inhook_Instruction` / `Outhook_Instruction`: Move carriers in/out of knitting area using yarn-inserting hook.
- `Releasehook_Instruction`: Release carriers on the yarn-inserting hook.
#### Machine Control
- `Rack_Instruction`: Set bed alignment and all-needle mode.
- `Pause_Instruction`: Pause machine execution.
#### Header Declarations
- `Machine_Header_Line`: Specify machine type.
- `Gauge_Header_Line`: Set machine gauge.
- `Yarn_Header_Line`: Define yarn properties.
- `Carriers_Header_Line`: Configure available carriers.
- `Position_Header_Line`: Set knitting position.
### Carriage Pass Organization
The library automatically organizes instructions into carriage passes:
```python
"""Example of what information can be gathered from carriage passes in the knitout execution."""
from knitout_interpreter.knitout_execution import Knitout_Executer
from knitout_interpreter.knitout_language.Knitout_Parser import parse_knitout
from virtual_knitting_machine.Knitting_Machine import Knitting_Machine
# Parse knitout file
parsed_instructions = parse_knitout("example.k", pattern_is_file=True)
executer = Knitout_Executer(
instructions=parsed_instructions,
knitting_machine=Knitting_Machine(),
accepted_error_types=[], # Optional: Knitting Machine Errors to ignore
knitout_version=2
)
for carriage_pass in executer.carriage_passes:
print(f"Pass direction: {carriage_pass.direction}")
print(f"Instructions: {len(carriage_pass)}")
print(f"Needle range: {carriage_pass.carriage_pass_range()}")
print(f"Carriers used: {carriage_pass.carrier_set}")
```
## 📖 Examples
### Example 1: Basic Stockinette
```python
"""Example of loading basic stockinette knitout from a string."""
from knitout_interpreter.knitout_language.Knitout_Parser import parse_knitout
knitout_code = """
;!knitout-2
;;Machine: SWG091N2
;;Gauge: 15
;;Yarn-5: 50-50 Rust
;;Carriers: 1 2 3 4 5 6 7 8 9 10
;;Position: Right
inhook 1;
tuck + f1 1;
tuck + f2 1;
tuck + f3 1;
tuck + f4 1;
knit - f4 1
knit - f3 1
knit - f2 1
knit - f1 1
knit + f1 1;
knit + f2 1;
knit + f3 1;
knit + f4 1;
knit - f4 1
knit - f3 1
knit - f2 1
knit - f1 1
releasehook 1;
outhook 1;
"""
instructions = parse_knitout(knitout_code)
# Process instructions...
```
### Example 2: Pattern Analysis
```python
"""Basic example of loading a pattern from a knitout file and analysing it."""
from knitout_interpreter.run_knitout import run_knitout
from knitout_interpreter.knitout_execution import Knitout_Executer
# Load complex pattern
instructions, machine, graph = run_knitout("complex_pattern.knitout")
# Analyze with executer
executer = Knitout_Executer(instructions, machine)
# Print analysis
print("=== Pattern Analysis ===")
print(f"Total instructions: {len(instructions)}")
print(f"Execution time: {executer.execution_time} passes")
print(f"Width: {executer.right_most_position - executer.left_most_position + 1} needles")
# Analyze carriage passes
for i, cp in enumerate(executer.carriage_passes):
print(f"Pass {i+1}: {cp}")
```
## 📋 Dependencies
### Runtime Dependencies
- `python` >= >=3.11,<3.13
- `parglare` ^0.18 - Parser generator for knitout grammar
- `knit-graphs` ^0.0.6 - Knitting graph data structures
- `virtual-knitting-machine` ^0.0.13 - Virtual machine simulation
- `importlib_resources` ^6.5. - Resource management
### Development Dependencies
- `mypy` - Static type checking
- `pre-commit` - Code quality hooks
- `coverage` - Test coverage measurement
- `sphinx` - Documentation generation
## 📄 License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
## 🙏 Acknowledgments
- **McCann et al.** for creating the [Knitout specification](https://textiles-lab.github.io/knitout/knitout.html)
- **Northeastern University ACT Lab** for supporting this research
- This work has been supported by the following NSF Grants:
- 2341880: HCC:SMALL:Tools for Programming and Designing Interactive Machine-Knitted Smart Textiles
- 2327137: Collaborative Research: HCC: Small: End-User Guided Search and Optimization for Accessible Product Customization and Design
## 📚 Related Projects
- Prior work by the CMU Textiles Lab:
- [knitout](https://github.com/textiles-lab/knitout) - Original knitout specification and tools
- [knitout-frontend-js](https://github.com/textiles-lab/knitout-frontend-js) - JavaScript knitout frontend
- Related Knitting Libraries from the Northeastern Act Lab
- [knit-graphs](https://pypi.org/project/knit-graphs/) - Knitting graph data structures
- [virtual-knitting-machine](https://pypi.org/project/virtual-knitting-machine/) - Virtual machine simulation
- [koda-knitout](https://pypi.org/project/koda-knitout/) - Optimization framework for knitout instructions
## 🔗 Links
- **PyPI Package**: https://pypi.org/project/knitout-interpreter
- **Documentation**: https://github.com/mhofmann-Khoury/knitout_interpreter#readme
- **Issue Tracker**: https://github.com/mhofmann-Khoury/knitout_interpreter/issues
---
**Made with ❤️ by the Northeastern University ACT Lab**
Raw data
{
"_id": null,
"home_page": "https://mhofmann-khoury.github.io/knitout_interpreter/",
"name": "knitout-interpreter",
"maintainer": "Megan Hofmann",
"docs_url": null,
"requires_python": "<3.13,>=3.11",
"maintainer_email": "m.hofmann@northeastern.edu",
"keywords": "knit, machine knit, textile, Northeastern, ACT Lab, fabrication, knitout",
"author": "Megan Hofmann",
"author_email": "m.hofmann@northeastern.edu",
"download_url": "https://files.pythonhosted.org/packages/19/73/cf7a4b7f4c0e28704048d3ea171a1e29a8de622a539b2bedc3a8d3ce4266/knitout_interpreter-0.0.21.tar.gz",
"platform": null,
"description": "# knitout-interpreter\n\n[](https://pypi.org/project/knitout-interpreter)\n[](https://pypi.org/project/knitout-interpreter)\n[](https://opensource.org/licenses/MIT)\n[](https://mypy-lang.org/)\n[](https://github.com/pre-commit/pre-commit)\n\nA comprehensive Python library for interpreting and executing knitout files used to control automatic V-Bed knitting machines.\nThis library provides full support for the [Knitout specification](https://textiles-lab.github.io/knitout/knitout.html) created by McCann et al.,\nenabling programmatic knitting pattern analysis, validation, and execution simulation.\n\n## \ud83d\udcd1 Table of Contents\n\n- [\ud83e\uddf6 Overview](#-overview)\n- [\ud83d\ude80 Key Features](#-key-features)\n- [\ud83d\udce6 Installation](#-installation)\n- [\ud83d\udcda Core Components](#-core-components)\n - [Knitout Executer](#knitout-executer)\n - [Instruction Types](#instruction-types)\n - [Carriage Pass Organization](#carriage-pass-organization)\n- [\ud83d\udcd6 Examples](#-examples)\n- [\ud83d\udccb Dependencies](#-dependencies)\n- [\ud83d\udcc4 License](#-license)\n- [\ud83d\ude4f Acknowledgments](#-acknowledgments)\n- [\ud83d\udcda Related Projects](#-related-projects)\n- [\ud83d\udd17 Links](#-links)\n\n## \ud83e\uddf6 Overview\n\nThe knitout-interpreter bridges the gap between high-level knitting pattern descriptions and machine-level execution. It provides tools for:\n\n- **Parsing** knitout files into structured Python objects\n- **Validating** knitting instructions against common errors\n- **Simulating** execution on virtual knitting machines\n- **Analyzing** patterns for timing, width requirements, and complexity\n- **Reorganizing** instructions for optimal machine execution\n\n## \ud83d\ude80 Key Features\n\n### Core Functionality\n- \u2705 Full compliance with Knitout specification v2\n- \u2705 Support for all needle operations (knit, tuck, split, drop, xfer, miss, kick)\n- \u2705 Carrier management (in, out, inhook, outhook, releasehook)\n- \u2705 Racking and positioning controls\n- \u2705 Header processing (machine, gauge, yarn, carriers, position)\n\n### Advanced Analysis\n- \ud83d\udcca **Execution Time Analysis**: Measure knitting time in carriage passes\n- \ud83d\udccf **Width Calculation**: Determine required needle bed width\n- \ud83d\udd0d **Error Detection**: Identify common knitting errors before execution\n- \ud83d\udcc8 **Knit Graph Generation**: Create structured representations of the final fabric\n\n### Virtual Machine Integration\n- \ud83d\udda5\ufe0f Built on the [virtual-knitting-machine](https://pypi.org/project/virtual-knitting-machine/) library\n- \ud83e\udde0 Maintains complete machine state during execution\n- \ud83d\udccb Tracks loop creation, movement, and removal from the machine bed\n- \u26a0\ufe0f Provides detailed warnings for potential issues\n\n## \ud83d\udce6 Installation\n\n### From PyPI (Recommended)\n```bash\npip install knitout-interpreter\n```\n\n### From Source\n```bash\ngit clone https://github.com/mhofmann-Khoury/knitout_interpreter.git\ncd knitout_interpreter\npip install -e .\n```\n\n### Development Installation\n```bash\ngit clone https://github.com/mhofmann-Khoury/knitout_interpreter.git\ncd knitout_interpreter\npip install -e \".[dev]\"\npre-commit install\n```\n\n### From Test-PyPi\nIf you wish to install an unstable release from test-PyPi, note that this will have dependencies on PyPi repository.\nUse the following command to gather those dependencies during install.\n```bash\npip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ knitout-interpreter\n```\n## \ud83c\udfc3\u200d\u2642\ufe0f Quick Start\n\n### Basic Usage\n\n```python\n\"\"\"Example Run of Knitout processed into instruction, final machine state, and resulting knit_graph\"\"\"\nfrom knitout_interpreter.run_knitout import run_knitout\n\n# Parse and execute a knitout file\ninstructions, machine, knit_graph = run_knitout(\"pattern.k\")\n\nprint(f\"Executed {len(instructions)} instructions\")\n```\n\n### Advanced Analysis with Knitout Executer\n\n```python\n\"\"\" Example of parsing knitout lines from the knitout parser and organizing the executed instructions with the Knitout Executer.\"\"\"\nfrom knitout_interpreter.knitout_execution import Knitout_Executer\nfrom knitout_interpreter.knitout_language.Knitout_Parser import parse_knitout\nfrom virtual_knitting_machine.Knitting_Machine import Knitting_Machine\n\n# Parse knitout file\ninstructions = parse_knitout(\"complex_pattern.k\", pattern_is_file=True)\n\n# Execute with analysis\nexecuter = Knitout_Executer(instructions, Knitting_Machine())\n\n# Get execution metrics\nprint(f\"Execution time: {executer.execution_time} carriage passes\")\nprint(f\"Width required: {executer.left_most_position} to {executer.right_most_position}\")\n\n# Save reorganized instructions\nexecuter.write_executed_instructions(\"executed_pattern.k\")\n```\n\n## \ud83d\udcda Core Components\n\n### Knitout Executer\nThe main analysis class that provides comprehensive execution simulation:\n\n```python\n\"\"\"Example of loading a fully specified Knitout Executer\"\"\"\nfrom knitout_interpreter.knitout_execution import Knitout_Executer\nfrom knitout_interpreter.knitout_language.Knitout_Parser import parse_knitout\nfrom virtual_knitting_machine.Knitting_Machine import Knitting_Machine\n\n# Parse knitout file\nparsed_instructions = parse_knitout(\"example.k\", pattern_is_file=True)\n\nexecuter = Knitout_Executer(\n instructions=parsed_instructions,\n knitting_machine=Knitting_Machine(),\n accepted_error_types=[], # Optional: Knitting Machine Errors to ignore\n knitout_version=2\n)\n```\n\n**Key Properties:**\n- `execution_time`: Number of carriage passes that will be executed\n- `left_most_position` / `right_most_position`: The range of needle positions in the executed file.\n- `carriage_passes`: List of carriage passes in the order they are executed.\n- `resulting_knit_graph`: Final fabric structure\n\n### Instruction Types\n\nThe library supports all knitout operations as Python classes:\n\n#### Needle Operations\n- `Knit_Instruction`: Create new loops, stitch through the old one.\n- `Tuck_Instruction`: Create new loops, keeping old ones.\n- `Split_Instruction`: Creates a loop on first specified needle while moving existing loops to the second specified needle.\n- `Drop_Instruction`: Remove loops from needles\n- `Xfer_Instruction`: Transfer loops between needles\n- `Miss_Instruction`: Position carriers without forming loops\n- `Kick_Instruction`: Specialized miss for kickbacks\n\n#### Carrier Operations\n- `In_Instruction` / `Out_Instruction`: Move carriers in/out of knitting area\n- `Inhook_Instruction` / `Outhook_Instruction`: Move carriers in/out of knitting area using yarn-inserting hook.\n- `Releasehook_Instruction`: Release carriers on the yarn-inserting hook.\n\n#### Machine Control\n- `Rack_Instruction`: Set bed alignment and all-needle mode.\n- `Pause_Instruction`: Pause machine execution.\n\n#### Header Declarations\n- `Machine_Header_Line`: Specify machine type.\n- `Gauge_Header_Line`: Set machine gauge.\n- `Yarn_Header_Line`: Define yarn properties.\n- `Carriers_Header_Line`: Configure available carriers.\n- `Position_Header_Line`: Set knitting position.\n\n### Carriage Pass Organization\n\nThe library automatically organizes instructions into carriage passes:\n\n```python\n\"\"\"Example of what information can be gathered from carriage passes in the knitout execution.\"\"\"\nfrom knitout_interpreter.knitout_execution import Knitout_Executer\nfrom knitout_interpreter.knitout_language.Knitout_Parser import parse_knitout\nfrom virtual_knitting_machine.Knitting_Machine import Knitting_Machine\n\n# Parse knitout file\nparsed_instructions = parse_knitout(\"example.k\", pattern_is_file=True)\n\nexecuter = Knitout_Executer(\n instructions=parsed_instructions,\n knitting_machine=Knitting_Machine(),\n accepted_error_types=[], # Optional: Knitting Machine Errors to ignore\n knitout_version=2\n)\n\nfor carriage_pass in executer.carriage_passes:\n print(f\"Pass direction: {carriage_pass.direction}\")\n print(f\"Instructions: {len(carriage_pass)}\")\n print(f\"Needle range: {carriage_pass.carriage_pass_range()}\")\n print(f\"Carriers used: {carriage_pass.carrier_set}\")\n```\n\n## \ud83d\udcd6 Examples\n\n### Example 1: Basic Stockinette\n\n```python\n\"\"\"Example of loading basic stockinette knitout from a string.\"\"\"\nfrom knitout_interpreter.knitout_language.Knitout_Parser import parse_knitout\n\nknitout_code = \"\"\"\n;!knitout-2\n;;Machine: SWG091N2\n;;Gauge: 15\n;;Yarn-5: 50-50 Rust\n;;Carriers: 1 2 3 4 5 6 7 8 9 10\n;;Position: Right\ninhook 1;\ntuck + f1 1;\ntuck + f2 1;\ntuck + f3 1;\ntuck + f4 1;\nknit - f4 1\nknit - f3 1\nknit - f2 1\nknit - f1 1\nknit + f1 1;\nknit + f2 1;\nknit + f3 1;\nknit + f4 1;\nknit - f4 1\nknit - f3 1\nknit - f2 1\nknit - f1 1\nreleasehook 1;\nouthook 1;\n\"\"\"\n\ninstructions = parse_knitout(knitout_code)\n# Process instructions...\n```\n\n### Example 2: Pattern Analysis\n\n```python\n\"\"\"Basic example of loading a pattern from a knitout file and analysing it.\"\"\"\nfrom knitout_interpreter.run_knitout import run_knitout\nfrom knitout_interpreter.knitout_execution import Knitout_Executer\n\n# Load complex pattern\ninstructions, machine, graph = run_knitout(\"complex_pattern.knitout\")\n\n# Analyze with executer\nexecuter = Knitout_Executer(instructions, machine)\n\n# Print analysis\nprint(\"=== Pattern Analysis ===\")\nprint(f\"Total instructions: {len(instructions)}\")\nprint(f\"Execution time: {executer.execution_time} passes\")\nprint(f\"Width: {executer.right_most_position - executer.left_most_position + 1} needles\")\n\n# Analyze carriage passes\nfor i, cp in enumerate(executer.carriage_passes):\n print(f\"Pass {i+1}: {cp}\")\n```\n\n## \ud83d\udccb Dependencies\n\n### Runtime Dependencies\n- `python` >= >=3.11,<3.13\n- `parglare` ^0.18 - Parser generator for knitout grammar\n- `knit-graphs` ^0.0.6 - Knitting graph data structures\n- `virtual-knitting-machine` ^0.0.13 - Virtual machine simulation\n- `importlib_resources` ^6.5. - Resource management\n\n### Development Dependencies\n- `mypy` - Static type checking\n- `pre-commit` - Code quality hooks\n- `coverage` - Test coverage measurement\n- `sphinx` - Documentation generation\n\n## \ud83d\udcc4 License\n\nThis project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.\n\n## \ud83d\ude4f Acknowledgments\n\n- **McCann et al.** for creating the [Knitout specification](https://textiles-lab.github.io/knitout/knitout.html)\n- **Northeastern University ACT Lab** for supporting this research\n- This work has been supported by the following NSF Grants:\n - 2341880: HCC:SMALL:Tools for Programming and Designing Interactive Machine-Knitted Smart Textiles\n - 2327137: Collaborative Research: HCC: Small: End-User Guided Search and Optimization for Accessible Product Customization and Design\n\n## \ud83d\udcda Related Projects\n\n- Prior work by the CMU Textiles Lab:\n - [knitout](https://github.com/textiles-lab/knitout) - Original knitout specification and tools\n - [knitout-frontend-js](https://github.com/textiles-lab/knitout-frontend-js) - JavaScript knitout frontend\n- Related Knitting Libraries from the Northeastern Act Lab\n - [knit-graphs](https://pypi.org/project/knit-graphs/) - Knitting graph data structures\n - [virtual-knitting-machine](https://pypi.org/project/virtual-knitting-machine/) - Virtual machine simulation\n - [koda-knitout](https://pypi.org/project/koda-knitout/) - Optimization framework for knitout instructions\n\n\n## \ud83d\udd17 Links\n\n- **PyPI Package**: https://pypi.org/project/knitout-interpreter\n- **Documentation**: https://github.com/mhofmann-Khoury/knitout_interpreter#readme\n- **Issue Tracker**: https://github.com/mhofmann-Khoury/knitout_interpreter/issues\n\n---\n\n**Made with \u2764\ufe0f by the Northeastern University ACT Lab**\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "Support for interpreting knitout files used for controlling automatic V-Bed Knitting machines.",
"version": "0.0.21",
"project_urls": {
"Bug Tracker": "https://github.com/mhofmann-Khoury/knitout_interpreter/issues",
"Documentation": "https://mhofmann-khoury.github.io/knitout_interpreter/",
"Homepage": "https://mhofmann-khoury.github.io/knitout_interpreter/",
"Repository": "https://github.com/mhofmann-Khoury/knitout_interpreter"
},
"split_keywords": [
"knit",
" machine knit",
" textile",
" northeastern",
" act lab",
" fabrication",
" knitout"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "0b2fba82677b19b35cccd32b5c00c28a9a6be145f919e664a55d9a996a1a4d81",
"md5": "402e29ab67ba019d0ddec81841949ef6",
"sha256": "043fe78ec571a218fe6fb2cc2ceae4ed66ccb30ada6e80a80fdc757d26cc010b"
},
"downloads": -1,
"filename": "knitout_interpreter-0.0.21-py3-none-any.whl",
"has_sig": false,
"md5_digest": "402e29ab67ba019d0ddec81841949ef6",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": "<3.13,>=3.11",
"size": 43953,
"upload_time": "2025-08-08T20:31:05",
"upload_time_iso_8601": "2025-08-08T20:31:05.222517Z",
"url": "https://files.pythonhosted.org/packages/0b/2f/ba82677b19b35cccd32b5c00c28a9a6be145f919e664a55d9a996a1a4d81/knitout_interpreter-0.0.21-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "1973cf7a4b7f4c0e28704048d3ea171a1e29a8de622a539b2bedc3a8d3ce4266",
"md5": "cea44b1d4a01f77b13246e8a2848a928",
"sha256": "3d508a57c0ab0a222269d19aec2848f1bf036a4c6c8df1c75eeb68026743e8e3"
},
"downloads": -1,
"filename": "knitout_interpreter-0.0.21.tar.gz",
"has_sig": false,
"md5_digest": "cea44b1d4a01f77b13246e8a2848a928",
"packagetype": "sdist",
"python_version": "source",
"requires_python": "<3.13,>=3.11",
"size": 3825792,
"upload_time": "2025-08-08T20:31:06",
"upload_time_iso_8601": "2025-08-08T20:31:06.655956Z",
"url": "https://files.pythonhosted.org/packages/19/73/cf7a4b7f4c0e28704048d3ea171a1e29a8de622a539b2bedc3a8d3ce4266/knitout_interpreter-0.0.21.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-08-08 20:31:06",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "mhofmann-Khoury",
"github_project": "knitout_interpreter",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"requirements": [
{
"name": "parglare",
"specs": [
[
"~=",
"0.16.1"
]
]
},
{
"name": "knit-graphs",
"specs": [
[
"~=",
"0.0.6"
]
]
},
{
"name": "virtual-knitting-machine",
"specs": [
[
"~=",
"0.0.13"
]
]
},
{
"name": "importlib_resources",
"specs": []
}
],
"lcname": "knitout-interpreter"
}
JSON
