''

app.py

@@ -0,0 +1,302 @@
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+import math
+from typing import Tuple, Optional
+import requests
+import json
+
+class BulletDistanceCalculator:
+    """A comprehensive bullet distance calculator with physics modeling."""
+    
+    def __init__(self):
+        self.gravity = 9.81  # m/s²
+        self.air_density = 1.225  # kg/m³ at sea level
+        
+    def calculate_trajectory(self, 
+                           initial_velocity: float, 
+                           angle: float, 
+                           bullet_mass: float = 0.01, 
+                           drag_coefficient: float = 0.3,
+                           bullet_diameter: float = 0.007) -> Tuple[np.ndarray, np.ndarray, dict]:
+        """
+        Calculate bullet trajectory with air resistance.
+        
+        Args:
+            initial_velocity: Initial velocity in m/s
+            angle: Launch angle in degrees
+            bullet_mass: Mass of bullet in kg
+            drag_coefficient: Drag coefficient
+            bullet_diameter: Bullet diameter in meters
+            
+        Returns:
+            Tuple of (x_coords, y_coords, results_dict)
+        """
+        angle_rad = math.radians(angle)
+        vx = initial_velocity * math.cos(angle_rad)
+        vy = initial_velocity * math.sin(angle_rad)
+        
+        # Calculate cross-sectional area
+        area = math.pi * (bullet_diameter / 2) ** 2
+        
+        # Time step for numerical integration
+        dt = 0.01
+        max_time = 20  # seconds
+        
+        x_coords = [0]
+        y_coords = [0]
+        t = 0
+        
+        while t < max_time and y_coords[-1] >= 0:
+            # Calculate drag force
+            velocity = math.sqrt(vx**2 + vy**2)
+            if velocity > 0:
+                drag_force = 0.5 * self.air_density * velocity**2 * drag_coefficient * area
+                drag_x = -drag_force * (vx / velocity)
+                drag_y = -drag_force * (vy / velocity)
+            else:
+                drag_x = drag_y = 0
+            
+            # Update velocities
+            vx += (drag_x / bullet_mass) * dt
+            vy += ((drag_y / bullet_mass) - self.gravity) * dt
+            
+            # Update positions
+            x = x_coords[-1] + vx * dt
+            y = y_coords[-1] + vy * dt
+            
+            if y < 0:  # Ground impact
+                # Linear interpolation to find exact impact point
+                y_prev = y_coords[-1]
+                x_prev = x_coords[-1]
+                t_impact = t - dt + dt * (-y_prev) / (y - y_prev)
+                x_impact = x_prev + vx * (t_impact - t + dt)
+                x_coords.append(x_impact)
+                y_coords.append(0)
+                break
+            
+            x_coords.append(x)
+            y_coords.append(y)
+            t += dt
+        
+        # Calculate results
+        max_height = max(y_coords)
+        range_distance = x_coords[-1]
+        flight_time = t
+        
+        results = {
+            'range': range_distance,
+            'max_height': max_height,
+            'flight_time': flight_time,
+            'final_velocity': math.sqrt(vx**2 + vy**2),
+            'impact_angle': math.degrees(math.atan2(vy, vx))
+        }
+        
+        return np.array(x_coords), np.array(y_coords), results
+
+def create_trajectory_plot(x_coords: np.ndarray, y_coords: np.ndarray, results: dict) -> str:
+    """Create a matplotlib plot of the trajectory."""
+    plt.figure(figsize=(10, 6))
+    plt.plot(x_coords, y_coords, 'b-', linewidth=2, label='Trajectory')
+    plt.scatter([0], [0], color='green', s=100, label='Launch Point', zorder=5)
+    plt.scatter([x_coords[-1]], [y_coords[-1]], color='red', s=100, label='Impact Point', zorder=5)
+    
+    plt.xlabel('Distance (m)')
+    plt.ylabel('Height (m)')
+    plt.title(f'Bullet Trajectory\nRange: {results["range"]:.1f}m, Max Height: {results["max_height"]:.1f}m')
+    plt.grid(True, alpha=0.3)
+    plt.legend()
+    plt.axis('equal')
+    
+    # Save plot
+    plot_path = "trajectory_plot.png"
+    plt.savefig(plot_path, dpi=150, bbox_inches='tight')
+    plt.close()
+    
+    return plot_path
+
+def calculate_bullet_distance(velocity: float, 
+                            angle: float, 
+                            mass: float, 
+                            drag_coeff: float, 
+                            diameter: float) -> Tuple[str, str, str]:
+    """
+    Main function for Gradio interface.
+    
+    Returns:
+        Tuple of (results_text, plot_path, detailed_info)
+    """
+    try:
+        calculator = BulletDistanceCalculator()
+        x_coords, y_coords, results = calculator.calculate_trajectory(
+            velocity, angle, mass, drag_coeff, diameter
+        )
+        
+        # Create plot
+        plot_path = create_trajectory_plot(x_coords, y_coords, results)
+        
+        # Format results
+        results_text = f"""
+🎯 **Bullet Distance Calculation Results**
+
+📏 **Range**: {results['range']:.2f} meters
+📈 **Maximum Height**: {results['max_height']:.2f} meters  
+⏱️ **Flight Time**: {results['flight_time']:.2f} seconds
+🚀 **Final Velocity**: {results['final_velocity']:.2f} m/s
+📐 **Impact Angle**: {results['impact_angle']:.1f}°
+        """
+        
+        detailed_info = f"""
+**Physics Parameters:**
+- Initial Velocity: {velocity} m/s
+- Launch Angle: {angle}°
+- Bullet Mass: {mass} kg
+- Drag Coefficient: {drag_coeff}
+- Bullet Diameter: {diameter} m
+
+**Environmental Conditions:**
+- Gravity: {calculator.gravity} m/s²
+- Air Density: {calculator.air_density} kg/m³
+        """
+        
+        return results_text, plot_path, detailed_info
+        
+    except Exception as e:
+        error_msg = f"❌ Error in calculation: {str(e)}"
+        return error_msg, None, error_msg
+
+def get_huggingface_model_info(model_name: str) -> str:
+    """Get information about a Hugging Face model."""
+    try:
+        api_url = f"https://huggingface.co/api/models/{model_name}"
+        response = requests.get(api_url, timeout=10)
+        
+        if response.status_code == 200:
+            model_data = response.json()
+            info = f"""
+🤗 **Hugging Face Model Information**
+
+**Model**: {model_data.get('modelId', 'Unknown')}
+**Downloads**: {model_data.get('downloads', 0):,}
+**Tags**: {', '.join(model_data.get('tags', []))}
+**Pipeline Tag**: {model_data.get('pipeline_tag', 'N/A')}
+**Library**: {model_data.get('library_name', 'N/A')}
+**Last Modified**: {model_data.get('lastModified', 'N/A')}
+            """
+            return info
+        else:
+            return f"❌ Error fetching model info: HTTP {response.status_code}"
+            
+    except Exception as e:
+        return f"❌ Error connecting to Hugging Face: {str(e)}"
+
+# Create Gradio interface
+with gr.Blocks(title="Bullet Distance Calculator", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🎯 Bullet Distance Calculator
+    
+    Calculate bullet trajectory with realistic physics including air resistance, drag, and gravity.
+    This app interfaces with Hugging Face and provides comprehensive ballistics calculations.
+    """)
+    
+    with gr.Tabs():
+        with gr.TabItem("🎯 Ballistics Calculator"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Input Parameters")
+                    
+                    velocity = gr.Slider(
+                        minimum=100, maximum=1000, value=300, step=10,
+                        label="Initial Velocity (m/s)",
+                        info="Typical rifle: 300-800 m/s"
+                    )
+                    
+                    angle = gr.Slider(
+                        minimum=0, maximum=90, value=30, step=1,
+                        label="Launch Angle (degrees)",
+                        info="0° = horizontal, 90° = vertical"
+                    )
+                    
+                    mass = gr.Slider(
+                        minimum=0.001, maximum=0.1, value=0.01, step=0.001,
+                        label="Bullet Mass (kg)",
+                        info="Typical: 0.005-0.02 kg"
+                    )
+                    
+                    drag_coeff = gr.Slider(
+                        minimum=0.1, maximum=1.0, value=0.3, step=0.01,
+                        label="Drag Coefficient",
+                        info="Typical: 0.2-0.5"
+                    )
+                    
+                    diameter = gr.Slider(
+                        minimum=0.005, maximum=0.02, value=0.007, step=0.001,
+                        label="Bullet Diameter (m)",
+                        info="Typical: 0.005-0.01 m"
+                    )
+                    
+                    calculate_btn = gr.Button("🚀 Calculate Trajectory", variant="primary")
+                
+                with gr.Column(scale=2):
+                    gr.Markdown("### Results")
+                    results_output = gr.Markdown()
+                    
+                    gr.Markdown("### Trajectory Plot")
+                    plot_output = gr.Image(label="Trajectory Visualization")
+                    
+                    gr.Markdown("### Detailed Information")
+                    detailed_output = gr.Markdown()
+        
+        with gr.TabItem("🤗 Hugging Face Integration"):
+            gr.Markdown("### Hugging Face Model Information")
+            
+            with gr.Row():
+                model_input = gr.Textbox(
+                    label="Model Name",
+                    placeholder="e.g., microsoft/DialoGPT-medium",
+                    value="microsoft/DialoGPT-medium"
+                )
+                fetch_btn = gr.Button("🔍 Get Model Info", variant="secondary")
+            
+            hf_output = gr.Markdown()
+        
+        with gr.TabItem("📚 About"):
+            gr.Markdown("""
+            ## About This App
+            
+            This Bullet Distance Calculator provides:
+            
+            - **Realistic Physics**: Includes air resistance, drag, and gravity
+            - **Interactive Visualization**: Real-time trajectory plotting
+            - **Hugging Face Integration**: Access to model information
+            - **Comprehensive Results**: Range, height, flight time, and more
+            
+            ### Physics Model
+            The calculator uses numerical integration to solve the equations of motion:
+            - Accounts for air resistance using drag coefficient
+            - Considers bullet mass and cross-sectional area
+            - Models realistic environmental conditions
+            
+            ### Hugging Face Features
+            - Fetch model information and statistics
+            - Access model metadata and tags
+            - Real-time API integration
+            
+            Built with Gradio and designed for Hugging Face Spaces deployment.
+            """)
+    
+    # Event handlers
+    calculate_btn.click(
+        fn=calculate_bullet_distance,
+        inputs=[velocity, angle, mass, drag_coeff, diameter],
+        outputs=[results_output, plot_output, detailed_output]
+    )
+    
+    fetch_btn.click(
+        fn=get_huggingface_model_info,
+        inputs=[model_input],
+        outputs=[hf_output]
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=True,mcp_server=True)

requirements.txt

@@ -0,0 +1,2 @@
+matplotlib
+gradio