Upload 10 files

Method 1: Upload via Web Interface
Go to your repository at https://huggingface.co/NuBest/height-conversion-tool
Click "Files and versions" tab
Click "Add file" → "Upload files" button
Drag and drop all files or click to browse and select multiple files
Add a commit message (e.g., "Add project files")
Click "Commit changes to main"
Tip: You can upload multiple files at once by selecting them all together.Method 2: Upload via Python (Recommended)This method uploads all files in one command:pythonfrom huggingface_hub import login, upload_folder

# Step 1: Login with your Hugging Face credentials
login()

# Step 2: Upload entire folder to repository
upload_folder(
folder_path=".", # Current directory with all files
repo_id="NuBest/height-conversion-tool",
repo_type="model"
)Installation:
bashpip install huggingface_hubUsage:
bashpython upload_script.py


Method 3: Upload via Git (For Developers)
This method uses Git commands for version control:
bash# Step 1: Clone your repository
git clone https://huggingface.co/NuBest/height-conversion-tool
cd height-conversion-tool

# Step 2: Copy all project files into this directory
# (Copy README.md, height_converter.py, requirements.txt, etc.)

# Step 3: Add files to Git
git add .

# Step 4: Commit with a message
git commit -m "Add complete project files and documentation"

# Step 5: Push to Hugging Face
git push
For first-time Git setup:
bash# Configure git with your Hugging Face credentials
git config user.email "your-email@example.com"
git config user.name "Your Name"

# Use your HF token as password when pushing
# Username: your-hf-username
# Password: your-hf-access-token

Method 4: Upload via CLI (huggingface-cli)
Quick command-line upload:
bash# Install CLI
pip install huggingface_hub[cli]

# Login
huggingface-cli login

# Upload a single file
huggingface-cli upload NuBest/height-conversion-tool README.md

# Upload entire directory
huggingface-cli upload NuBest/height-conversion-tool . --repo-type=model

CONTRIBUTING.md

@@ -0,0 +1,315 @@
+# Contributing to Height Conversion Tool
+
+Thank you for your interest in contributing to the Height Conversion Tool! We welcome contributions from the community.
+
+## Table of Contents
+
+- [Code of Conduct](#code-of-conduct)
+- [Getting Started](#getting-started)
+- [How to Contribute](#how-to-contribute)
+- [Development Setup](#development-setup)
+- [Coding Standards](#coding-standards)
+- [Testing Guidelines](#testing-guidelines)
+- [Submitting Changes](#submitting-changes)
+- [Reporting Bugs](#reporting-bugs)
+- [Suggesting Enhancements](#suggesting-enhancements)
+
+## Code of Conduct
+
+This project follows a simple code of conduct: be respectful, be constructive, and be collaborative. We aim to maintain a welcoming environment for all contributors.
+
+## Getting Started
+
+1. **Fork the repository** on Hugging Face
+2. **Clone your fork** to your local machine:
+   ```bash
+   git clone https://huggingface.co/YOUR_USERNAME/height-conversion-tool
+   cd height-conversion-tool
+   ```
+
+3. **Set up development environment** (see below)
+
+## How to Contribute
+
+There are many ways to contribute:
+
+- 🐛 **Report bugs** - Help us identify and fix issues
+- ✨ **Suggest features** - Share ideas for improvements
+- 📝 **Improve documentation** - Help others understand the tool better
+- 🔧 **Submit bug fixes** - Fix issues you've found
+- 🚀 **Add new features** - Implement new functionality
+- ✅ **Write tests** - Improve test coverage
+- 🌍 **Add translations** - Help make the tool multilingual
+
+## Development Setup
+
+### Prerequisites
+
+- Python 3.8 or higher
+- pip
+- git
+
+### Installation Steps
+
+1. **Create a virtual environment**:
+   ```bash
+   python -m venv venv
+   ```
+
+2. **Activate the virtual environment**:
+   - On Linux/Mac:
+     ```bash
+     source venv/bin/activate
+     ```
+   - On Windows:
+     ```bash
+     venv\Scripts\activate
+     ```
+
+3. **Install development dependencies**:
+   ```bash
+   pip install -r requirements-dev.txt
+   ```
+
+4. **Install the package in editable mode**:
+   ```bash
+   pip install -e .
+   ```
+
+### Verify Installation
+
+Run the tests to make sure everything is working:
+```bash
+pytest tests/ -v
+```
+
+## Coding Standards
+
+### Python Style Guide
+
+We follow [PEP 8](https://pep8.org/) with some modifications:
+
+- **Line length**: Maximum 100 characters
+- **Indentation**: 4 spaces (no tabs)
+- **Quotes**: Use double quotes for strings
+- **Imports**: Group and sort alphabetically
+
+### Code Formatting
+
+We use **Black** for automatic code formatting:
+```bash
+black height_converter.py
+```
+
+### Linting
+
+We use **flake8** for linting:
+```bash
+flake8 height_converter.py
+```
+
+### Type Hints
+
+Please include type hints for function parameters and return values:
+```python
+def feet_to_cm(self, feet: int, inches: float = 0) -> float:
+    """Convert feet and inches to centimeters."""
+    pass
+```
+
+## Testing Guidelines
+
+### Writing Tests
+
+- Place tests in the `tests/` directory
+- Name test files with `test_` prefix
+- Name test functions with `test_` prefix
+- Use descriptive test names
+
+Example:
+```python
+def test_feet_to_cm_with_decimal_inches():
+    """Test conversion with decimal inch values."""
+    converter = HeightConverter()
+    result = converter.feet_to_cm(5, 10.5)
+    assert result == pytest.approx(179.07, rel=0.01)
+```
+
+### Running Tests
+
+Run all tests:
+```bash
+pytest
+```
+
+Run with coverage:
+```bash
+pytest --cov=height_converter --cov-report=html
+```
+
+Run specific test file:
+```bash
+pytest tests/test_height_converter.py -v
+```
+
+### Test Coverage
+
+We aim for at least 90% test coverage. Check coverage with:
+```bash
+pytest --cov=height_converter --cov-report=term-missing
+```
+
+## Submitting Changes
+
+### Branching Strategy
+
+1. **Create a new branch** from `main`:
+   ```bash
+   git checkout -b feature/your-feature-name
+   ```
+
+   Branch naming conventions:
+   - `feature/` - New features
+   - `bugfix/` - Bug fixes
+   - `docs/` - Documentation updates
+   - `test/` - Test improvements
+
+2. **Make your changes** following our coding standards
+
+3. **Write or update tests** for your changes
+
+4. **Run the test suite** to ensure everything passes:
+   ```bash
+   pytest
+   black .
+   flake8
+   ```
+
+5. **Commit your changes** with a clear message:
+   ```bash
+   git add .
+   git commit -m "Add feature: description of your changes"
+   ```
+
+   Commit message format:
+   ```
+   <type>: <short description>
+   
+   <optional detailed description>
+   
+   <optional footer>
+   ```
+
+   Types: `feat`, `fix`, `docs`, `test`, `refactor`, `style`, `chore`
+
+6. **Push to your fork**:
+   ```bash
+   git push origin feature/your-feature-name
+   ```
+
+7. **Create a Pull Request** on Hugging Face
+
+### Pull Request Guidelines
+
+Your PR should:
+
+- ✅ Have a clear title and description
+- ✅ Reference any related issues
+- ✅ Include tests for new functionality
+- ✅ Update documentation if needed
+- ✅ Pass all CI checks
+- ✅ Have no merge conflicts
+
+**PR Template:**
+```markdown
+## Description
+Brief description of your changes
+
+## Type of Change
+- [ ] Bug fix
+- [ ] New feature
+- [ ] Documentation update
+- [ ] Performance improvement
+
+## Testing
+Describe how you tested your changes
+
+## Checklist
+- [ ] Code follows style guidelines
+- [ ] Tests added/updated
+- [ ] Documentation updated
+- [ ] All tests passing
+```
+
+## Reporting Bugs
+
+### Before Submitting a Bug Report
+
+- Check the documentation
+- Search existing issues
+- Try the latest version
+
+### How to Submit a Good Bug Report
+
+Include:
+
+1. **Clear title** - Concise summary of the issue
+2. **Description** - Detailed explanation
+3. **Steps to reproduce** - Exact steps to trigger the bug
+4. **Expected behavior** - What should happen
+5. **Actual behavior** - What actually happens
+6. **Environment** - OS, Python version, package version
+7. **Code sample** - Minimal reproducible example
+
+**Template:**
+```markdown
+**Environment:**
+- OS: [e.g., Ubuntu 22.04]
+- Python version: [e.g., 3.10.5]
+- Package version: [e.g., 1.0.0]
+
+**Description:**
+[Clear description of the bug]
+
+**Steps to Reproduce:**
+1. Step 1
+2. Step 2
+3. Step 3
+
+**Expected Behavior:**
+[What should happen]
+
+**Actual Behavior:**
+[What actually happens]
+
+**Code Sample:**
+```python
+# Minimal code to reproduce the issue
+```
+```
+
+## Suggesting Enhancements
+
+We welcome enhancement suggestions! Please include:
+
+1. **Use case** - Why is this enhancement needed?
+2. **Proposed solution** - How should it work?
+3. **Alternatives** - Other approaches considered
+4. **Additional context** - Screenshots, examples, etc.
+
+## Questions?
+
+If you have questions about contributing, feel free to:
+
+- Open a discussion on Hugging Face
+- Ask in the community forum
+- Contact the maintainers
+
+## Recognition
+
+Contributors will be recognized in:
+- The project README
+- Release notes
+- Our hall of fame (coming soon!)
+
+Thank you for contributing to Height Conversion Tool! 🎉

LICENSE

@@ -0,0 +1,85 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work.
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
+
+(a) You must give any other recipients of the Work or Derivative Works a copy of this License; and
+
+(b) You must cause any modified files to carry prominent notices stating that You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+Copyright 2025 NuBest Team
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

README.md

@@ -1,12 +1,292 @@
 ---
 license: apache-2.0
-language:
-- en
-pipeline_tag: unconditional-image-generation
 tags:
-- unit-converter
 - height-conversion
+- utility
 - measurement
-- calculator
-- metric-imperial
----
+- unit-conversion
+language:
+- en
+- vi
+---
+
+# Height Conversion Tool
+
+A simple and efficient tool for converting height measurements between different units (feet/inches, centimeters, meters).
+
+## Model Overview
+
+This tool provides accurate height conversions between various measurement systems commonly used around the world. It supports bidirectional conversions and handles multiple input formats.
+
+## Features
+
+- **Multiple Unit Support**: Convert between feet/inches, centimeters, and meters
+- **Flexible Input**: Accepts various input formats (e.g., "5'10\"", "178 cm", "1.78 m")
+- **High Accuracy**: Maintains precision across conversions
+- **Easy to Use**: Simple API with clear documentation
+- **Bilingual**: Supports English and Vietnamese
+
+## Supported Conversions
+
+| From | To | Example |
+|------|-----|---------|
+| Feet & Inches | Centimeters | 5'10" → 177.8 cm |
+| Centimeters | Feet & Inches | 180 cm → 5'11" |
+| Meters | Feet & Inches | 1.75 m → 5'9" |
+| Feet & Inches | Meters | 6'0" → 1.83 m |
+| Centimeters | Meters | 170 cm → 1.7 m |
+
+## Installation
+
+```bash
+pip install height-conversion-tool
+```
+
+Or clone this repository:
+
+```bash
+git clone https://huggingface.co/NuBest/height-conversion-tool
+cd height-conversion-tool
+pip install -r requirements.txt
+```
+
+## Quick Start
+
+### Python Usage
+
+```python
+from height_converter import HeightConverter
+
+# Initialize converter
+converter = HeightConverter()
+
+# Convert from feet/inches to centimeters
+height_cm = converter.feet_to_cm(5, 10)  # 5 feet 10 inches
+print(f"Height: {height_cm} cm")  # Output: Height: 177.8 cm
+
+# Convert from centimeters to feet/inches
+feet, inches = converter.cm_to_feet(180)
+print(f"Height: {feet}'{inches}\"")  # Output: Height: 5'11"
+
+# String input format
+result = converter.convert("5'10\"", to_unit="cm")
+print(result)  # Output: 177.8 cm
+```
+
+### Command Line Usage
+
+```bash
+# Convert height
+python height_converter.py --input "5'10\"" --output cm
+
+# Multiple conversions
+python height_converter.py --input 180 --from cm --to feet
+```
+
+## API Reference
+
+### HeightConverter Class
+
+#### Methods
+
+**`feet_to_cm(feet: int, inches: float = 0) -> float`**
+- Converts feet and inches to centimeters
+- Parameters:
+  - `feet`: Number of feet
+  - `inches`: Number of inches (optional, default: 0)
+- Returns: Height in centimeters
+
+**`cm_to_feet(cm: float) -> tuple[int, float]`**
+- Converts centimeters to feet and inches
+- Parameters:
+  - `cm`: Height in centimeters
+- Returns: Tuple of (feet, inches)
+
+**`meters_to_feet(meters: float) -> tuple[int, float]`**
+- Converts meters to feet and inches
+- Parameters:
+  - `meters`: Height in meters
+- Returns: Tuple of (feet, inches)
+
+**`convert(input_str: str, to_unit: str = "cm") -> str`**
+- Flexible conversion from string input
+- Parameters:
+  - `input_str`: Height string (e.g., "5'10\"", "180cm", "1.8m")
+  - `to_unit`: Target unit ("cm", "feet", "meters")
+- Returns: Converted height as string
+
+## Use Cases
+
+- **Healthcare**: Converting patient height measurements between metric and imperial systems
+- **Fitness Apps**: Standardizing height inputs across different regions
+- **E-commerce**: Converting size charts for international customers
+- **Travel Apps**: Helping users understand height requirements in different countries
+- **Education**: Teaching measurement conversions
+
+## Technical Details
+
+### Conversion Formulas
+
+- 1 inch = 2.54 cm
+- 1 foot = 12 inches = 30.48 cm
+- 1 meter = 100 cm = 3.28084 feet
+
+### Accuracy
+
+The tool maintains precision up to 2 decimal places for centimeters and meters, and up to 1 decimal place for inches.
+
+## Examples
+
+### Example 1: Basic Conversion
+
+```python
+from height_converter import HeightConverter
+
+converter = HeightConverter()
+
+# Convert 6 feet to centimeters
+result = converter.feet_to_cm(6, 0)
+print(f"6 feet = {result} cm")  # Output: 6 feet = 182.88 cm
+```
+
+### Example 2: Batch Conversion
+
+```python
+heights_cm = [150, 160, 170, 180, 190]
+
+for height in heights_cm:
+    feet, inches = converter.cm_to_feet(height)
+    print(f"{height} cm = {feet}'{inches:.1f}\"")
+```
+
+Output:
+```
+150 cm = 4'11.1"
+160 cm = 5'3.0"
+170 cm = 5'7.0"
+180 cm = 5'10.9"
+190 cm = 6'2.8"
+```
+
+### Example 3: Web Integration
+
+```python
+from flask import Flask, request, jsonify
+from height_converter import HeightConverter
+
+app = Flask(__name__)
+converter = HeightConverter()
+
+@app.route('/convert', methods=['POST'])
+def convert_height():
+    data = request.json
+    input_height = data.get('height')
+    to_unit = data.get('to_unit', 'cm')
+    
+    result = converter.convert(input_height, to_unit)
+    return jsonify({'result': result})
+
+if __name__ == '__main__':
+    app.run(debug=True)
+```
+
+## Testing
+
+Run the test suite:
+
+```bash
+python -m pytest tests/
+```
+
+Run specific tests:
+
+```bash
+python -m pytest tests/test_converter.py -v
+```
+
+## Contributing
+
+We welcome contributions! Please follow these steps:
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+### Development Setup
+
+```bash
+# Clone repository
+git clone https://huggingface.co/NuBest/height-conversion-tool
+cd height-conversion-tool
+
+# Create virtual environment
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install development dependencies
+pip install -r requirements-dev.txt
+
+# Run tests
+pytest
+```
+
+## License
+
+This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.
+
+## Citation
+
+If you use this tool in your research or project, please cite:
+
+```bibtex
+@software{height_conversion_tool,
+  author = {NuBest},
+  title = {Height Conversion Tool},
+  year = {2025},
+  url = {https://huggingface.co/NuBest/height-conversion-tool}
+}
+```
+
+## Support
+
+- **Issues**: [GitHub Issues](https://huggingface.co/NuBest/height-conversion-tool/discussions)
+- **Discussions**: [Community Forum](https://huggingface.co/NuBest/height-conversion-tool/discussions)
+- **Email**: support@nubest.com
+
+## Changelog
+
+### Version 1.0.0 (2025-01-29)
+- Initial release
+- Support for feet/inches, centimeters, and meters
+- Command line interface
+- Python API
+- Comprehensive test suite
+
+## Acknowledgments
+
+- Built with Python 3.8+
+- Inspired by the need for accurate height conversions in international applications
+- Special thanks to the Hugging Face community
+
+## FAQ
+
+**Q: What's the maximum height that can be converted?**
+A: The tool supports heights up to 999 cm (32'9") to cover all practical use cases.
+
+**Q: How accurate are the conversions?**
+A: Conversions maintain precision up to 2 decimal places, which is sufficient for all practical purposes.
+
+**Q: Can I use this in a commercial application?**
+A: Yes, the Apache 2.0 license allows commercial use with proper attribution.
+
+**Q: Does it support other units like yards or kilometers?**
+A: Currently, the tool focuses on the most commonly used units (feet/inches, cm, meters). Additional units may be added in future versions.
+
+**Q: How do I handle invalid input?**
+A: The tool includes input validation and raises clear error messages for invalid inputs.
+
+---
+
+Made with ❤️ by NuBest Team

example_usage.py

@@ -0,0 +1,91 @@
+"""
+Example usage of Height Conversion Tool
+"""
+
+from height_converter import HeightConverter
+
+
+def main():
+    """Demonstrate various uses of the HeightConverter."""
+    
+    # Initialize converter
+    converter = HeightConverter()
+    
+    print("=" * 60)
+    print("Height Conversion Tool - Examples")
+    print("=" * 60)
+    
+    # Example 1: Convert feet/inches to cm
+    print("\n1. Convert 5'10\" to centimeters:")
+    height_cm = converter.feet_to_cm(5, 10)
+    print(f"   Result: {height_cm} cm")
+    
+    # Example 2: Convert cm to feet/inches
+    print("\n2. Convert 180 cm to feet/inches:")
+    feet, inches = converter.cm_to_feet(180)
+    print(f"   Result: {feet}'{inches}\"")
+    
+    # Example 3: Convert meters to feet/inches
+    print("\n3. Convert 1.75 meters to feet/inches:")
+    feet, inches = converter.meters_to_feet(1.75)
+    print(f"   Result: {feet}'{inches}\"")
+    
+    # Example 4: Convert feet to meters
+    print("\n4. Convert 6 feet to meters:")
+    meters = converter.feet_to_meters(6, 0)
+    print(f"   Result: {meters} m")
+    
+    # Example 5: Using string input
+    print("\n5. Convert using string input:")
+    heights = ["5'10\"", "180cm", "1.75m"]
+    for height in heights:
+        result_cm = converter.convert(height, "cm")
+        result_feet = converter.convert(height, "feet")
+        print(f"   {height:10} = {result_cm:12} = {result_feet}")
+    
+    # Example 6: Batch conversion
+    print("\n6. Batch conversion (cm to feet/inches):")
+    heights_cm = [150, 160, 170, 180, 190]
+    print(f"   {'CM':<6} {'Feet/Inches':<12}")
+    print(f"   {'-'*6} {'-'*12}")
+    for height in heights_cm:
+        feet, inches = converter.cm_to_feet(height)
+        print(f"   {height:<6} {feet}'{inches:.1f}\"")
+    
+    # Example 7: Height comparison
+    print("\n7. Height comparison:")
+    person1 = {"name": "Alice", "height": "5'6\""}
+    person2 = {"name": "Bob", "height": "175cm"}
+    
+    alice_cm = converter.feet_to_cm(5, 6)
+    bob_cm = 175
+    
+    print(f"   {person1['name']}: {person1['height']} = {alice_cm} cm")
+    print(f"   {person2['name']}: {person2['height']} = {bob_cm} cm")
+    
+    if alice_cm > bob_cm:
+        print(f"   {person1['name']} is taller by {alice_cm - bob_cm:.1f} cm")
+    elif bob_cm > alice_cm:
+        print(f"   {person2['name']} is taller by {bob_cm - alice_cm:.1f} cm")
+    else:
+        print(f"   They are the same height!")
+    
+    # Example 8: Error handling
+    print("\n8. Error handling:")
+    try:
+        converter.feet_to_cm(-5, 10)
+    except ValueError as e:
+        print(f"   Caught error: {e}")
+    
+    try:
+        converter.parse_height_string("invalid input")
+    except ValueError as e:
+        print(f"   Caught error: {e}")
+    
+    print("\n" + "=" * 60)
+    print("Examples completed!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

gitignore

@@ -0,0 +1,139 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Project specific
+*.log
+temp/
+tmp/

height_converter.py

@@ -0,0 +1,270 @@
+"""
+Height Conversion Tool
+A simple and efficient tool for converting height measurements between different units.
+"""
+
+from typing import Tuple, Union
+import re
+
+
+class HeightConverter:
+    """Main class for height conversions."""
+    
+    # Conversion constants
+    INCH_TO_CM = 2.54
+    FEET_TO_CM = 30.48
+    FEET_TO_INCH = 12
+    CM_TO_INCH = 1 / INCH_TO_CM
+    METER_TO_CM = 100
+    
+    def __init__(self):
+        """Initialize the HeightConverter."""
+        pass
+    
+    def feet_to_cm(self, feet: Union[int, float], inches: float = 0) -> float:
+        """
+        Convert feet and inches to centimeters.
+        
+        Args:
+            feet: Number of feet
+            inches: Number of inches (default: 0)
+            
+        Returns:
+            Height in centimeters
+            
+        Examples:
+            >>> converter = HeightConverter()
+            >>> converter.feet_to_cm(5, 10)
+            177.8
+        """
+        if feet < 0 or inches < 0:
+            raise ValueError("Height values cannot be negative")
+        
+        total_inches = (feet * self.FEET_TO_INCH) + inches
+        cm = total_inches * self.INCH_TO_CM
+        return round(cm, 2)
+    
+    def cm_to_feet(self, cm: float) -> Tuple[int, float]:
+        """
+        Convert centimeters to feet and inches.
+        
+        Args:
+            cm: Height in centimeters
+            
+        Returns:
+            Tuple of (feet, inches)
+            
+        Examples:
+            >>> converter = HeightConverter()
+            >>> converter.cm_to_feet(180)
+            (5, 10.9)
+        """
+        if cm < 0:
+            raise ValueError("Height cannot be negative")
+        
+        total_inches = cm * self.CM_TO_INCH
+        feet = int(total_inches // self.FEET_TO_INCH)
+        inches = total_inches % self.FEET_TO_INCH
+        return feet, round(inches, 1)
+    
+    def meters_to_feet(self, meters: float) -> Tuple[int, float]:
+        """
+        Convert meters to feet and inches.
+        
+        Args:
+            meters: Height in meters
+            
+        Returns:
+            Tuple of (feet, inches)
+            
+        Examples:
+            >>> converter = HeightConverter()
+            >>> converter.meters_to_feet(1.75)
+            (5, 8.9)
+        """
+        if meters < 0:
+            raise ValueError("Height cannot be negative")
+        
+        cm = meters * self.METER_TO_CM
+        return self.cm_to_feet(cm)
+    
+    def feet_to_meters(self, feet: Union[int, float], inches: float = 0) -> float:
+        """
+        Convert feet and inches to meters.
+        
+        Args:
+            feet: Number of feet
+            inches: Number of inches (default: 0)
+            
+        Returns:
+            Height in meters
+            
+        Examples:
+            >>> converter = HeightConverter()
+            >>> converter.feet_to_meters(6, 0)
+            1.83
+        """
+        cm = self.feet_to_cm(feet, inches)
+        meters = cm / self.METER_TO_CM
+        return round(meters, 2)
+    
+    def cm_to_meters(self, cm: float) -> float:
+        """
+        Convert centimeters to meters.
+        
+        Args:
+            cm: Height in centimeters
+            
+        Returns:
+            Height in meters
+        """
+        if cm < 0:
+            raise ValueError("Height cannot be negative")
+        
+        return round(cm / self.METER_TO_CM, 2)
+    
+    def meters_to_cm(self, meters: float) -> float:
+        """
+        Convert meters to centimeters.
+        
+        Args:
+            meters: Height in meters
+            
+        Returns:
+            Height in centimeters
+        """
+        if meters < 0:
+            raise ValueError("Height cannot be negative")
+        
+        return round(meters * self.METER_TO_CM, 2)
+    
+    def parse_height_string(self, height_str: str) -> dict:
+        """
+        Parse a height string into its components.
+        
+        Args:
+            height_str: Height string (e.g., "5'10\"", "180cm", "1.8m")
+            
+        Returns:
+            Dictionary with parsed values and unit
+            
+        Examples:
+            >>> converter = HeightConverter()
+            >>> converter.parse_height_string("5'10\"")
+            {'feet': 5, 'inches': 10, 'unit': 'feet'}
+        """
+        height_str = height_str.strip().lower()
+        
+        # Pattern for feet and inches (5'10", 5'10, 5ft10in, etc.)
+        feet_pattern = r"(\d+)(?:'|ft|feet)\s*(\d+(?:\.\d+)?)?(?:\"|in|inches)?"
+        match = re.match(feet_pattern, height_str)
+        if match:
+            feet = int(match.group(1))
+            inches = float(match.group(2)) if match.group(2) else 0
+            return {'feet': feet, 'inches': inches, 'unit': 'feet'}
+        
+        # Pattern for centimeters (180cm, 180 cm)
+        cm_pattern = r"(\d+(?:\.\d+)?)\s*cm"
+        match = re.match(cm_pattern, height_str)
+        if match:
+            cm = float(match.group(1))
+            return {'cm': cm, 'unit': 'cm'}
+        
+        # Pattern for meters (1.8m, 1.8 m)
+        m_pattern = r"(\d+(?:\.\d+)?)\s*m(?:eters?)?"
+        match = re.match(m_pattern, height_str)
+        if match:
+            meters = float(match.group(1))
+            return {'meters': meters, 'unit': 'meters'}
+        
+        raise ValueError(f"Unable to parse height string: {height_str}")
+    
+    def convert(self, input_str: str, to_unit: str = "cm") -> str:
+        """
+        Flexible conversion from string input.
+        
+        Args:
+            input_str: Height string (e.g., "5'10\"", "180cm", "1.8m")
+            to_unit: Target unit ("cm", "feet", "meters")
+            
+        Returns:
+            Converted height as formatted string
+            
+        Examples:
+            >>> converter = HeightConverter()
+            >>> converter.convert("5'10\"", "cm")
+            '177.8 cm'
+        """
+        parsed = self.parse_height_string(input_str)
+        to_unit = to_unit.lower()
+        
+        # Convert to target unit
+        if to_unit == "cm":
+            if parsed['unit'] == 'feet':
+                result = self.feet_to_cm(parsed['feet'], parsed['inches'])
+                return f"{result} cm"
+            elif parsed['unit'] == 'meters':
+                result = self.meters_to_cm(parsed['meters'])
+                return f"{result} cm"
+            else:
+                return f"{parsed['cm']} cm"
+        
+        elif to_unit == "feet":
+            if parsed['unit'] == 'cm':
+                feet, inches = self.cm_to_feet(parsed['cm'])
+                return f"{feet}'{inches:.1f}\""
+            elif parsed['unit'] == 'meters':
+                feet, inches = self.meters_to_feet(parsed['meters'])
+                return f"{feet}'{inches:.1f}\""
+            else:
+                return f"{parsed['feet']}'{parsed['inches']:.1f}\""
+        
+        elif to_unit == "meters" or to_unit == "m":
+            if parsed['unit'] == 'feet':
+                result = self.feet_to_meters(parsed['feet'], parsed['inches'])
+                return f"{result} m"
+            elif parsed['unit'] == 'cm':
+                result = self.cm_to_meters(parsed['cm'])
+                return f"{result} m"
+            else:
+                return f"{parsed['meters']} m"
+        
+        else:
+            raise ValueError(f"Unknown target unit: {to_unit}")
+
+
+def main():
+    """Command line interface for the height converter."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(
+        description='Convert height between different units'
+    )
+    parser.add_argument(
+        'height',
+        type=str,
+        help='Height to convert (e.g., "5\'10\"", "180cm", "1.8m")'
+    )
+    parser.add_argument(
+        '--to',
+        type=str,
+        default='cm',
+        choices=['cm', 'feet', 'meters', 'm'],
+        help='Target unit (default: cm)'
+    )
+    
+    args = parser.parse_args()
+    
+    converter = HeightConverter()
+    try:
+        result = converter.convert(args.height, args.to)
+        print(result)
+    except ValueError as e:
+        print(f"Error: {e}")
+        return 1
+    
+    return 0
+
+
+if __name__ == '__main__':
+    exit(main())

requirements-dev.txt

@@ -0,0 +1,22 @@
+# Include base requirements
+-r requirements.txt
+
+# Additional development tools
+pytest-xdist>=2.5.0  # Parallel test execution
+pytest-mock>=3.10.0  # Mocking support
+coverage>=6.5.0      # Code coverage
+
+# Code quality
+pylint>=2.15.0
+autopep8>=2.0.0
+isort>=5.11.0
+
+# Type checking
+types-click>=8.0.0
+
+# Pre-commit hooks
+pre-commit>=2.20.0
+
+# Jupyter for experimentation
+jupyter>=1.0.0
+ipython>=8.0.0

requirements.txt

@@ -0,0 +1,25 @@
+# Core dependencies
+numpy>=1.21.0
+pandas>=1.3.0
+
+# CLI support
+click>=8.0.0
+argparse>=1.4.0
+
+# Testing
+pytest>=7.0.0
+pytest-cov>=3.0.0
+
+# Development
+black>=22.0.0
+flake8>=4.0.0
+mypy>=0.950
+
+# Documentation
+sphinx>=4.5.0
+sphinx-rtd-theme>=1.0.0
+
+# Optional: Web API support
+flask>=2.0.0
+fastapi>=0.95.0
+uvicorn>=0.21.0

setup.py

@@ -0,0 +1,66 @@
+"""
+Setup configuration for height-conversion-tool
+"""
+
+from setuptools import setup, find_packages
+from pathlib import Path
+
+# Read the README file
+this_directory = Path(__file__).parent
+long_description = (this_directory / "README.md").read_text(encoding='utf-8')
+
+setup(
+    name="height-conversion-tool",
+    version="1.0.0",
+    author="NuBest Team",
+    author_email="support@nubest.com",
+    description="A simple and efficient tool for converting height measurements between different units",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://huggingface.co/NuBest/height-conversion-tool",
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Healthcare Industry",
+        "Topic :: Scientific/Engineering",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "License :: OSI Approved :: Apache Software License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Operating System :: OS Independent",
+    ],
+    keywords="height conversion measurement unit-converter feet inches centimeters meters",
+    python_requires=">=3.8",
+    install_requires=[
+        "numpy>=1.21.0",
+        "click>=8.0.0",
+    ],
+    extras_require={
+        "dev": [
+            "pytest>=7.0.0",
+            "pytest-cov>=3.0.0",
+            "black>=22.0.0",
+            "flake8>=4.0.0",
+            "mypy>=0.950",
+        ],
+        "web": [
+            "flask>=2.0.0",
+            "fastapi>=0.95.0",
+            "uvicorn>=0.21.0",
+        ],
+    },
+    entry_points={
+        "console_scripts": [
+            "height-convert=height_converter:main",
+        ],
+    },
+    project_urls={
+        "Bug Reports": "https://huggingface.co/NuBest/height-conversion-tool/discussions",
+        "Source": "https://huggingface.co/NuBest/height-conversion-tool",
+        "Documentation": "https://huggingface.co/NuBest/height-conversion-tool",
+    },
+)

test_height_converter.py

@@ -0,0 +1,149 @@
+"""
+Unit tests for HeightConverter
+"""
+
+import pytest
+from height_converter import HeightConverter
+
+
+class TestHeightConverter:
+    """Test suite for HeightConverter class."""
+    
+    @pytest.fixture
+    def converter(self):
+        """Create a HeightConverter instance for testing."""
+        return HeightConverter()
+    
+    # Test feet to cm conversions
+    def test_feet_to_cm_basic(self, converter):
+        """Test basic feet to cm conversion."""
+        result = converter.feet_to_cm(5, 10)
+        assert result == 177.8
+    
+    def test_feet_to_cm_no_inches(self, converter):
+        """Test feet to cm with no inches."""
+        result = converter.feet_to_cm(6)
+        assert result == 182.88
+    
+    def test_feet_to_cm_negative(self, converter):
+        """Test that negative values raise ValueError."""
+        with pytest.raises(ValueError):
+            converter.feet_to_cm(-5, 10)
+    
+    # Test cm to feet conversions
+    def test_cm_to_feet_basic(self, converter):
+        """Test basic cm to feet conversion."""
+        feet, inches = converter.cm_to_feet(180)
+        assert feet == 5
+        assert inches == pytest.approx(10.9, rel=0.1)
+    
+    def test_cm_to_feet_short(self, converter):
+        """Test cm to feet for shorter height."""
+        feet, inches = converter.cm_to_feet(150)
+        assert feet == 4
+        assert inches == pytest.approx(11.1, rel=0.1)
+    
+    def test_cm_to_feet_negative(self, converter):
+        """Test that negative cm raises ValueError."""
+        with pytest.raises(ValueError):
+            converter.cm_to_feet(-180)
+    
+    # Test meters conversions
+    def test_meters_to_feet(self, converter):
+        """Test meters to feet conversion."""
+        feet, inches = converter.meters_to_feet(1.75)
+        assert feet == 5
+        assert inches == pytest.approx(8.9, rel=0.1)
+    
+    def test_feet_to_meters(self, converter):
+        """Test feet to meters conversion."""
+        result = converter.feet_to_meters(6, 0)
+        assert result == 1.83
+    
+    def test_cm_to_meters(self, converter):
+        """Test cm to meters conversion."""
+        result = converter.cm_to_meters(175)
+        assert result == 1.75
+    
+    def test_meters_to_cm(self, converter):
+        """Test meters to cm conversion."""
+        result = converter.meters_to_cm(1.8)
+        assert result == 180.0
+    
+    # Test string parsing
+    def test_parse_feet_inches_standard(self, converter):
+        """Test parsing standard feet/inches format."""
+        result = converter.parse_height_string("5'10\"")
+        assert result == {'feet': 5, 'inches': 10, 'unit': 'feet'}
+    
+    def test_parse_feet_inches_no_quotes(self, converter):
+        """Test parsing feet/inches without quotes."""
+        result = converter.parse_height_string("5'10")
+        assert result == {'feet': 5, 'inches': 10, 'unit': 'feet'}
+    
+    def test_parse_cm(self, converter):
+        """Test parsing centimeters."""
+        result = converter.parse_height_string("180cm")
+        assert result == {'cm': 180.0, 'unit': 'cm'}
+    
+    def test_parse_cm_with_space(self, converter):
+        """Test parsing cm with space."""
+        result = converter.parse_height_string("180 cm")
+        assert result == {'cm': 180.0, 'unit': 'cm'}
+    
+    def test_parse_meters(self, converter):
+        """Test parsing meters."""
+        result = converter.parse_height_string("1.8m")
+        assert result == {'meters': 1.8, 'unit': 'meters'}
+    
+    def test_parse_invalid_format(self, converter):
+        """Test that invalid format raises ValueError."""
+        with pytest.raises(ValueError):
+            converter.parse_height_string("invalid")
+    
+    # Test convert method
+    def test_convert_feet_to_cm(self, converter):
+        """Test convert from feet to cm."""
+        result = converter.convert("5'10\"", "cm")
+        assert result == "177.8 cm"
+    
+    def test_convert_cm_to_feet(self, converter):
+        """Test convert from cm to feet."""
+        result = converter.convert("180cm", "feet")
+        assert "5'" in result
+        assert "10.9\"" in result
+    
+    def test_convert_meters_to_cm(self, converter):
+        """Test convert from meters to cm."""
+        result = converter.convert("1.75m", "cm")
+        assert result == "175.0 cm"
+    
+    def test_convert_cm_to_meters(self, converter):
+        """Test convert from cm to meters."""
+        result = converter.convert("180cm", "meters")
+        assert result == "1.8 m"
+    
+    def test_convert_invalid_unit(self, converter):
+        """Test that invalid target unit raises ValueError."""
+        with pytest.raises(ValueError):
+            converter.convert("180cm", "invalid")
+    
+    # Edge cases
+    def test_zero_height(self, converter):
+        """Test handling of zero height."""
+        result = converter.feet_to_cm(0, 0)
+        assert result == 0.0
+    
+    def test_very_tall_height(self, converter):
+        """Test handling of very tall height."""
+        result = converter.feet_to_cm(8, 0)
+        assert result == 243.84
+    
+    def test_decimal_inches(self, converter):
+        """Test handling of decimal inches."""
+        result = converter.feet_to_cm(5, 10.5)
+        assert result == pytest.approx(179.07, rel=0.01)
+
+
+if __name__ == '__main__':
+    pytest.main([__file__, '-v'])