gravixlayer 0.0.1__tar.gz

gravixlayer-0.0.1/.github/workflows/pypi-release.yml

@@ -0,0 +1,40 @@
+name: Publish and Release to PyPI
+
+on:
+  push:
+    tags:
+      - "v*.*.*"  # Triggers workflow on tags like v0.0.1
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+
+      - name: Install build tools
+        run: |
+          pip install --upgrade pip
+          pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_TOKEN }}
+
+  release:
+    needs: build-and-publish
+    runs-on: ubuntu-latest
+    steps:
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          generate_release_notes: true

gravixlayer-0.0.1/.gitignore

@@ -0,0 +1,99 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+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/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# 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/

gravixlayer-0.0.1/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include requirements.txt
+include version.py
+recursive-include gravixlayer *.py

gravixlayer-0.0.1/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: gravixlayer
+Version: 0.0.1
+Summary: GravixLayer Python SDK - OpenAI Compatible
+Home-page: https://github.com/sukrithpvs/gravixlayer-python
+Author: Sukrith
+Author-email: Sukrith <sukrithpvs@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/sukrithpvs/gravixlayer-python
+Project-URL: Repository, https://github.com/sukrithpvs/gravixlayer-python
+Project-URL: Issues, https://github.com/sukrithpvs/gravixlayer-python/issues
+Keywords: gravixlayer,openai,llm,ai,api,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Requires-Dist: python-dotenv>=0.19.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+text
+# GravixLayer Python SDK
+
+A Python SDK for GravixLayer API that's fully compatible with OpenAI's interface.
+
+## Installation
+
+pip install gravixlayer
+
+text
+
+## Quick Start
+
+import os
+from gravixlayer import GravixLayer
+Initialize client
+
+client = GravixLayer(
+api_key=os.environ.get("GRAVIXLAYER_API_KEY"),
+)
+Create completion
+
+completion = client.chat.completions.create(
+model="llama3.1:8b",
+messages=[
+{"role": "system", "content": "You are a helpful assistant."},
+{"role": "user", "content": "What are the three most popular programming languages?"}
+]
+)
+
+print(completion.choices.message.content)
+
+text
+
+## OpenAI Compatibility
+
+You can use this SDK as a drop-in replacement for OpenAI:
+
+from gravixlayer import OpenAI # This is an alias for GravixLayer
+
+client = OpenAI(
+base_url="https://api.gravixlayer.com/v1/inference",
+api_key=os.environ.get("GRAVIXLAYER_API_KEY"),
+)
+
+text
+
+## Features
+
+- **OpenAI Compatible**: Drop-in replacement for OpenAI Python SDK
+- **Streaming Support**: Real-time response streaming
+- **Error Handling**: Automatic retries and proper error handling
+- **Type Hints**: Full type support for better development experience
+- **Environment Variables**: Automatic API key detection
+
+## API Reference
+
+### Chat Completions
+
+completion = client.chat.completions.create(
+model="llama3.1:8b",
+messages=[...],
+temperature=0.7,
+max_tokens=150,
+top_p=1.0,
+frequency_penalty=0,
+presence_penalty=0,
+stop=None,
+stream=False
+)
+
+text
+
+### Streaming
+
+stream = client.chat.completions.create(
+model="llama3.1:8b",
+messages=[...],
+stream=True
+)
+
+for chunk in stream:
+if chunk.choices.delta.content is not None:
+print(chunk.choices.delta.content, end="")
+
+text
+
+## Environment Variables
+
+- `GRAVIXLAYER_API_KEY`: Your GravixLayer API key
+
+## License
+
+MIT License

gravixlayer-0.0.1/README.md

@@ -0,0 +1,94 @@
+text
+# GravixLayer Python SDK
+
+A Python SDK for GravixLayer API that's fully compatible with OpenAI's interface.
+
+## Installation
+
+pip install gravixlayer
+
+text
+
+## Quick Start
+
+import os
+from gravixlayer import GravixLayer
+Initialize client
+
+client = GravixLayer(
+api_key=os.environ.get("GRAVIXLAYER_API_KEY"),
+)
+Create completion
+
+completion = client.chat.completions.create(
+model="llama3.1:8b",
+messages=[
+{"role": "system", "content": "You are a helpful assistant."},
+{"role": "user", "content": "What are the three most popular programming languages?"}
+]
+)
+
+print(completion.choices.message.content)
+
+text
+
+## OpenAI Compatibility
+
+You can use this SDK as a drop-in replacement for OpenAI:
+
+from gravixlayer import OpenAI # This is an alias for GravixLayer
+
+client = OpenAI(
+base_url="https://api.gravixlayer.com/v1/inference",
+api_key=os.environ.get("GRAVIXLAYER_API_KEY"),
+)
+
+text
+
+## Features
+
+- **OpenAI Compatible**: Drop-in replacement for OpenAI Python SDK
+- **Streaming Support**: Real-time response streaming
+- **Error Handling**: Automatic retries and proper error handling
+- **Type Hints**: Full type support for better development experience
+- **Environment Variables**: Automatic API key detection
+
+## API Reference
+
+### Chat Completions
+
+completion = client.chat.completions.create(
+model="llama3.1:8b",
+messages=[...],
+temperature=0.7,
+max_tokens=150,
+top_p=1.0,
+frequency_penalty=0,
+presence_penalty=0,
+stop=None,
+stream=False
+)
+
+text
+
+### Streaming
+
+stream = client.chat.completions.create(
+model="llama3.1:8b",
+messages=[...],
+stream=True
+)
+
+for chunk in stream:
+if chunk.choices.delta.content is not None:
+print(chunk.choices.delta.content, end="")
+
+text
+
+## Environment Variables
+
+- `GRAVIXLAYER_API_KEY`: Your GravixLayer API key
+
+## License
+
+MIT License

gravixlayer-0.0.1/gravixlayer/__init__.py

@@ -0,0 +1,22 @@
+"""
+GravixLayer Python SDK - OpenAI Compatible
+"""
+__version__ = "0.0.1"
+
+from .client import GravixLayer
+from .types.chat import (
+    ChatCompletion,
+    ChatCompletionMessage,
+    ChatCompletionChoice,
+    ChatCompletionUsage,
+)
+OpenAI = GravixLayer
+
+__all__ = [
+    "GravixLayer",
+    "OpenAI",
+    "ChatCompletion",
+    "ChatCompletionMessage",
+    "ChatCompletionChoice",
+    "ChatCompletionUsage",
+]

gravixlayer-0.0.1/gravixlayer/cli.py

@@ -0,0 +1,46 @@
+import argparse
+import os
+from gravixlayer import GravixLayer
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="GravixLayer CLI – OpenAI-Compatible Chat Completions"
+    )
+    parser.add_argument("--api-key", type=str, default=None, help="API key")
+    parser.add_argument("--model", required=True, help="Model name (e.g., gemma3:12b)")
+    parser.add_argument("--system", default=None, help="System prompt (optional)")
+    parser.add_argument("--user", required=True, help="User prompt/message")
+    parser.add_argument("--temperature", type=float, default=None, help="Temperature")
+    parser.add_argument("--stream", action="store_true", help="Stream output (token-by-token)")
+    
+    args = parser.parse_args()
+
+    client = GravixLayer(api_key=args.api_key or os.environ.get("GRAVIXLAYER_API_KEY"))
+
+    messages = []
+    if args.system:
+        messages.append({"role": "system", "content": args.system})
+    messages.append({"role": "user", "content": args.user})
+
+    try:
+        if args.stream:
+            for chunk in client.chat.completions.create(
+                model=args.model,
+                messages=messages,
+                temperature=args.temperature,
+                stream=True
+            ):
+                print(chunk.choices[0].message.content, end="", flush=True)
+            print()
+        else:
+            completion = client.chat.completions.create(
+                model=args.model,
+                messages=messages,
+                temperature=args.temperature
+            )
+            print(completion.choices[0].message.content)
+    except Exception as e:
+        print(f"❌ Error: {e}")
+
+if __name__ == "__main__":
+    main()

gravixlayer-0.0.1/gravixlayer/client.py

@@ -0,0 +1,107 @@
+import os
+import requests
+import logging
+from typing import Optional, Dict, Any, Type
+from .resources.chat.completions import ChatCompletions
+from .types.exceptions import (
+    GravixLayerError,
+    GravixLayerAuthenticationError,
+    GravixLayerRateLimitError,
+    GravixLayerServerError,
+    GravixLayerBadRequestError,
+    GravixLayerConnectionError
+)
+
+class GravixLayer:
+    """
+    Main GravixLayer client - OpenAI compatible.
+    """
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        timeout: float = 60.0,
+        max_retries: int = 3,
+        headers: Optional[Dict[str, str]] = None,
+        logger: Optional[Type[logging.Logger]] = None,
+        user_agent: Optional[str] = None,
+    ):
+        self.api_key = api_key or os.environ.get("GRAVIXLAYER_API_KEY")
+        self.base_url = base_url or "https://api.gravixlayer.com/v1/inference"
+        if not self.base_url.startswith("https://"):
+            raise ValueError("Base URL must use HTTPS for security reasons.")
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.custom_headers = headers or {}
+        self.logger = logger or logging.getLogger("gravixlayer")
+        self.logger.setLevel(logging.INFO)
+        if not self.logger.hasHandlers():
+            logging.basicConfig(level=logging.INFO)
+        self.user_agent = user_agent or f"gravixlayer-python/0.0.1"
+        if not self.api_key:
+            raise ValueError("API key must be provided via argument or GRAVIXLAYER_API_KEY environment variable")
+        self.chat = ChatResource(self)
+
+    def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        stream: bool = False,
+        **kwargs
+    ) -> requests.Response:
+        url = f"{self.base_url.rstrip('/')}/{endpoint.lstrip('/')}" if endpoint else self.base_url
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "User-Agent": self.user_agent,
+            **self.custom_headers,
+        }
+        for attempt in range(self.max_retries + 1):
+            try:
+                resp = requests.request(
+                    method=method,
+                    url=url,
+                    headers=headers,
+                    json=data,
+                    timeout=self.timeout,
+                    stream=stream,
+                    **kwargs
+                )
+                if resp.status_code == 200:
+                    return resp
+                elif resp.status_code == 401:
+                    raise GravixLayerAuthenticationError("Authentication failed.")
+                elif resp.status_code == 429:
+                    retry_after = resp.headers.get("Retry-After")
+                    self.logger.warning(f"Rate limit exceeded. Retrying in {retry_after or 2**attempt}s...")
+                    if attempt < self.max_retries:
+                        import time
+                        time.sleep(float(retry_after) if retry_after else (2 ** attempt))
+                        continue
+                    raise GravixLayerRateLimitError(resp.text)
+                elif resp.status_code in [502, 503, 504] and attempt < self.max_retries:
+                    self.logger.warning(f"Server error: {resp.status_code}. Retrying...")
+                    import time
+                    time.sleep(2 ** attempt)
+                    continue
+                elif 400 <= resp.status_code < 500:
+                    raise GravixLayerBadRequestError(resp.text)
+                elif 500 <= resp.status_code < 600:
+                    raise GravixLayerServerError(resp.text)
+                else:
+                    resp.raise_for_status()
+            except requests.RequestException as e:
+                if attempt == self.max_retries:
+                    raise GravixLayerConnectionError(str(e)) from e
+                self.logger.warning("Transient connection error, retrying...")
+                import time
+                time.sleep(2 ** attempt)
+        raise GravixLayerError("Failed to complete request.")
+
+class ChatResource:
+    def __init__(self, client: GravixLayer):
+        self.client = client
+        self.completions = ChatCompletions(client)
+
+OpenAI = GravixLayer

gravixlayer-0.0.1/gravixlayer/resources/__init__.py

@@ -0,0 +1 @@
+# Resources module

gravixlayer-0.0.1/gravixlayer/resources/chat/__init__.py

@@ -0,0 +1,3 @@
+from .completions import ChatCompletions
+
+__all__ = ["ChatCompletions"]

gravixlayer-0.0.1/gravixlayer/resources/chat/completions.py

@@ -0,0 +1,99 @@
+from typing import Dict, Any, List, Optional, Union, Iterator
+import json
+from ...types.chat import ChatCompletion, ChatCompletionChoice, ChatCompletionMessage, ChatCompletionUsage
+
+class ChatCompletions:
+    """Chat completions resource"""
+
+    def __init__(self, client):
+        self.client = client
+
+    def create(
+        self,
+        model: str,
+        messages: List[Dict[str, str]],
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        top_p: Optional[float] = None,
+        frequency_penalty: Optional[float] = None,
+        presence_penalty: Optional[float] = None,
+        stop: Optional[Union[str, List[str]]] = None,
+        stream: bool = False,
+        **kwargs
+    ) -> Union[ChatCompletion, Iterator[ChatCompletion]]:
+        data = {
+            "model": model,
+            "messages": messages,
+            "stream": stream
+        }
+        if temperature is not None:
+            data["temperature"] = temperature
+        if max_tokens is not None:
+            data["max_tokens"] = max_tokens
+        if top_p is not None:
+            data["top_p"] = top_p
+        if frequency_penalty is not None:
+            data["frequency_penalty"] = frequency_penalty
+        if presence_penalty is not None:
+            data["presence_penalty"] = presence_penalty
+        if stop is not None:
+            data["stop"] = stop
+        data.update(kwargs)
+        return self._create_stream(data) if stream else self._create_non_stream(data)
+
+    def _create_non_stream(self, data: Dict[str, Any]) -> ChatCompletion:
+        resp = self.client._make_request("POST", "chat/completions", data)
+        return self._parse_response(resp.json())
+
+    def _create_stream(self, data: Dict[str, Any]) -> Iterator[ChatCompletion]:
+        resp = self.client._make_request("POST", "chat/completions", data, stream=True)
+        for line in resp.iter_lines():
+            if not line:
+                continue
+            line = line.decode("utf-8")
+            if line.startswith("data: "):
+                line = line[len("data: "):]
+            if line.strip() == "[DONE]":
+                break
+            try:
+                chunk = json.loads(line)
+                yield self._parse_response(chunk, is_stream=True)
+            except json.JSONDecodeError:
+                continue
+
+    def _parse_response(self, resp_data: Dict[str, Any], is_stream: bool = False) -> ChatCompletion:
+        if "choices" in resp_data:
+            choices = []
+            for choice in resp_data["choices"]:
+                msg = ChatCompletionMessage(
+                    role=choice.get("message", {}).get("role", "assistant"),
+                    content=choice.get("message", {}).get("content", "")
+                )
+                choices.append(ChatCompletionChoice(
+                    index=choice.get("index", 0),
+                    message=msg,
+                    finish_reason=choice.get("finish_reason")
+                ))
+        else:
+            content = resp_data.get("content", "")
+            if isinstance(resp_data, str):
+                content = resp_data
+            msg = ChatCompletionMessage(role="assistant", content=content)
+            choices = [ChatCompletionChoice(index=0, message=msg, finish_reason="stop")]
+
+        usage = None
+        if "usage" in resp_data:
+            usage = ChatCompletionUsage(
+                prompt_tokens=resp_data["usage"].get("prompt_tokens", 0),
+                completion_tokens=resp_data["usage"].get("completion_tokens", 0),
+                total_tokens=resp_data["usage"].get("total_tokens", 0),
+            )
+        import time
+        return ChatCompletion(
+            id=resp_data.get("id", "chatcmpl-" + str(hash(str(resp_data)))),
+            object="chat.completion" if not is_stream else "chat.completion.chunk",
+            created=resp_data.get("created", int(time.time())),
+            model=resp_data.get("model", "unknown"),
+            choices=choices,
+            usage=usage,
+        )

gravixlayer-0.0.1/gravixlayer/types/__init__.py

@@ -0,0 +1,13 @@
+from .chat import (
+    ChatCompletion,
+    ChatCompletionMessage,
+    ChatCompletionChoice,
+    ChatCompletionUsage,
+)
+
+__all__ = [
+    "ChatCompletion",
+    "ChatCompletionMessage", 
+    "ChatCompletionChoice",
+    "ChatCompletionUsage",
+]

gravixlayer-0.0.1/gravixlayer/types/async_client.py

@@ -0,0 +1,67 @@
+import os
+import httpx
+import logging
+from typing import Optional, Dict, Any
+from gravixlayer.resources.chat.completions import ChatCompletions
+
+class AsyncGravixLayer:
+    """
+    Async client for GravixLayer
+    """
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        timeout: float = 60.0,
+        max_retries: int = 3,
+        headers: Optional[Dict[str, str]] = None,
+        logger: Optional[logging.Logger] = None,
+        user_agent: Optional[str] = None,
+    ):
+        self.api_key = api_key or os.environ.get("GRAVIXLAYER_API_KEY")
+        self.base_url = base_url or "https://api.gravixlayer.com/v1/inference"
+        if not self.base_url.startswith("https://"):
+            raise ValueError("Base URL must use HTTPS for security reasons.")
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.custom_headers = headers or {}
+        self.logger = logger or logging.getLogger("gravixlayer-async")
+        self.user_agent = user_agent or f"gravixlayer-python/0.0.1"
+        if not self.api_key:
+            raise ValueError("API key must be provided via argument or GRAVIXLAYER_API_KEY environment variable")
+        self.chat = ChatCompletions(self)
+
+    async def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        stream: bool = False,
+        **kwargs
+    ) -> httpx.Response:
+        url = f"{self.base_url.rstrip('/')}/{endpoint.lstrip('/')}" if endpoint else self.base_url
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "User-Agent": self.user_agent,
+            **self.custom_headers,
+        }
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            for attempt in range(self.max_retries + 1):
+                try:
+                    resp = await client.request(
+                        method=method,
+                        url=url,
+                        headers=headers,
+                        json=data,
+                        **kwargs,
+                    )
+                    if resp.status_code == 200:
+                        return resp
+                    # TODO: map errors as in sync client (add equivalent exception handling)
+                except httpx.RequestError as e:
+                    if attempt == self.max_retries:
+                        raise e
+                    import asyncio
+                    await asyncio.sleep(2 ** attempt)
+        raise Exception("Failed async request")

gravixlayer-0.0.1/gravixlayer/types/chat.py

@@ -0,0 +1,30 @@
+from typing import Optional, List, Dict, Any
+from dataclasses import dataclass
+
+@dataclass
+class ChatCompletionMessage:
+    role: str
+    content: str
+    name: Optional[str] = None
+    function_call: Optional[Dict[str, Any]] = None
+
+@dataclass
+class ChatCompletionChoice:
+    index: int
+    message: ChatCompletionMessage
+    finish_reason: Optional[str] = None
+
+@dataclass
+class ChatCompletionUsage:
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+
+@dataclass
+class ChatCompletion:
+    id: str
+    object: str
+    created: int
+    model: str
+    choices: List[ChatCompletionChoice]
+    usage: Optional[ChatCompletionUsage] = None

gravixlayer-0.0.1/gravixlayer/types/exceptions.py

@@ -0,0 +1,18 @@
+class GravixLayerError(Exception):
+    """Base SDK exception"""
+    pass
+
+class GravixLayerAuthenticationError(GravixLayerError):
+    pass
+
+class GravixLayerRateLimitError(GravixLayerError):
+    pass
+
+class GravixLayerServerError(GravixLayerError):
+    pass
+
+class GravixLayerBadRequestError(GravixLayerError):
+    pass
+
+class GravixLayerConnectionError(GravixLayerError):
+    pass

gravixlayer-0.0.1/gravixlayer.egg-info/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: gravixlayer
+Version: 0.0.1
+Summary: GravixLayer Python SDK - OpenAI Compatible
+Home-page: https://github.com/sukrithpvs/gravixlayer-python
+Author: Sukrith
+Author-email: Sukrith <sukrithpvs@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/sukrithpvs/gravixlayer-python
+Project-URL: Repository, https://github.com/sukrithpvs/gravixlayer-python
+Project-URL: Issues, https://github.com/sukrithpvs/gravixlayer-python/issues
+Keywords: gravixlayer,openai,llm,ai,api,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Requires-Dist: python-dotenv>=0.19.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+text
+# GravixLayer Python SDK
+
+A Python SDK for GravixLayer API that's fully compatible with OpenAI's interface.
+
+## Installation
+
+pip install gravixlayer
+
+text
+
+## Quick Start
+
+import os
+from gravixlayer import GravixLayer
+Initialize client
+
+client = GravixLayer(
+api_key=os.environ.get("GRAVIXLAYER_API_KEY"),
+)
+Create completion
+
+completion = client.chat.completions.create(
+model="llama3.1:8b",
+messages=[
+{"role": "system", "content": "You are a helpful assistant."},
+{"role": "user", "content": "What are the three most popular programming languages?"}
+]
+)
+
+print(completion.choices.message.content)
+
+text
+
+## OpenAI Compatibility
+
+You can use this SDK as a drop-in replacement for OpenAI:
+
+from gravixlayer import OpenAI # This is an alias for GravixLayer
+
+client = OpenAI(
+base_url="https://api.gravixlayer.com/v1/inference",
+api_key=os.environ.get("GRAVIXLAYER_API_KEY"),
+)
+
+text
+
+## Features
+
+- **OpenAI Compatible**: Drop-in replacement for OpenAI Python SDK
+- **Streaming Support**: Real-time response streaming
+- **Error Handling**: Automatic retries and proper error handling
+- **Type Hints**: Full type support for better development experience
+- **Environment Variables**: Automatic API key detection
+
+## API Reference
+
+### Chat Completions
+
+completion = client.chat.completions.create(
+model="llama3.1:8b",
+messages=[...],
+temperature=0.7,
+max_tokens=150,
+top_p=1.0,
+frequency_penalty=0,
+presence_penalty=0,
+stop=None,
+stream=False
+)
+
+text
+
+### Streaming
+
+stream = client.chat.completions.create(
+model="llama3.1:8b",
+messages=[...],
+stream=True
+)
+
+for chunk in stream:
+if chunk.choices.delta.content is not None:
+print(chunk.choices.delta.content, end="")
+
+text
+
+## Environment Variables
+
+- `GRAVIXLAYER_API_KEY`: Your GravixLayer API key
+
+## License
+
+MIT License

gravixlayer-0.0.1/gravixlayer.egg-info/SOURCES.txt

@@ -0,0 +1,33 @@
+.gitignore
+CHANGELOG.md
+MANIFEST.in
+README.md
+pyproject.toml
+requirements.txt
+setup.py
+tempCodeRunnerFile.py
+test.py
+test2.py
+version.py
+.github/workflows/pypi-release.yml
+gravixlayer/__init__.py
+gravixlayer/cli.py
+gravixlayer/client.py
+gravixlayer.egg-info/PKG-INFO
+gravixlayer.egg-info/SOURCES.txt
+gravixlayer.egg-info/dependency_links.txt
+gravixlayer.egg-info/entry_points.txt
+gravixlayer.egg-info/requires.txt
+gravixlayer.egg-info/top_level.txt
+gravixlayer/resources/__init__.py
+gravixlayer/resources/chat/__init__.py
+gravixlayer/resources/chat/completions.py
+gravixlayer/types/__init__.py
+gravixlayer/types/async_client.py
+gravixlayer/types/chat.py
+gravixlayer/types/exceptions.py
+scripts/bump_version.py
+scripts/release.sh
+tests/test_chat_completions.py
+tests/test_client.py
+tests/test_exceptions.py

gravixlayer-0.0.1/gravixlayer.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gravixlayer-0.0.1/gravixlayer.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gravixlayer = gravixlayer.cli:main

gravixlayer-0.0.1/gravixlayer.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.25.0
+python-dotenv>=0.19.0

gravixlayer-0.0.1/gravixlayer.egg-info/top_level.txt

@@ -0,0 +1 @@
+gravixlayer

gravixlayer-0.0.1/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=45", "wheel", "setuptools_scm>=6.2"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "gravixlayer"
+dynamic = ["version"]
+description = "GravixLayer Python SDK - OpenAI Compatible"
+readme = "README.md"
+requires-python = ">=3.7"
+license = {text = "MIT"}
+authors = [
+    {name = "Sukrith", email = "sukrithpvs@gmail.com"},
+]
+keywords = ["gravixlayer", "openai", "llm", "ai", "api", "sdk"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+]
+dependencies = [
+    "requests>=2.25.0",
+    "python-dotenv>=0.19.0",
+]
+
+[project.scripts]
+gravixlayer = "gravixlayer.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/sukrithpvs/gravixlayer-python"
+Repository = "https://github.com/sukrithpvs/gravixlayer-python"
+Issues = "https://github.com/sukrithpvs/gravixlayer-python/issues"

gravixlayer-0.0.1/requirements.txt

@@ -0,0 +1,2 @@
+requests>=2.25.0
+python-dotenv>=0.19.0

gravixlayer-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

gravixlayer-0.0.1/setup.py

@@ -0,0 +1,52 @@
+import os
+from setuptools import setup, find_packages
+
+# Read version
+exec(open('version.py').read())
+
+# Read README
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+# Read requirements
+with open("requirements.txt", "r", encoding="utf-8") as fh:
+    requirements = [line.strip() for line in fh if line.strip() and not line.startswith("#")]
+
+setup(
+    name="gravixlayer",
+    version="0.0.1",
+    author="Sukrith",
+    author_email="sukrithpvs@gmail.com",
+    description="GravixLayer Python SDK - OpenAI Compatible",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/sukrithpvs/gravixlayer-python",
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
+    ],
+    python_requires=">=3.7",
+    install_requires=requirements,
+    entry_points={
+        'console_scripts': [
+            'gravixlayer=gravixlayer.cli:main',
+        ],
+    },
+    keywords="gravixlayer, openai, llm, ai, api, sdk",
+    project_urls={
+        "Bug Reports": "https://github.com/sukrithpvs/gravixlayer-python/issues",
+        "Source": "https://github.com/sukrithpvs/gravixlayer-python",
+        "Documentation": "https://github.com/sukrithpvs/gravixlayer-python/blob/main/README.md",
+    },
+)

gravixlayer-0.0.1/tempCodeRunnerFile.py

@@ -0,0 +1 @@
+

gravixlayer-0.0.1/test.py

@@ -0,0 +1,25 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+from gravixlayer import GravixLayer
+
+client = GravixLayer(
+    api_key=os.environ.get("GRAVIXLAYER_API_KEY"),
+)
+
+print(f"Testing  SDK...")
+
+try:
+    completion = client.chat.completions.create(
+        model="gemma3:12b",
+        messages=[
+            {"role": "system", "content": "You are a helpful and friendly assistant."},
+            {"role": "user", "content": "What is the capital of France?"}
+        ]
+    )
+    print("✅ Success!")
+    print(f"Response: {completion.choices[0].message.content}")
+except Exception as e:
+    print(f"❌ Error: {e}")

gravixlayer-0.0.1/test2.py

@@ -0,0 +1,12 @@
+import asyncio
+from gravixlayer.async_client import AsyncGravixLayer
+
+async def main():
+    client = AsyncGravixLayer()
+    result = await client.chat.completions.create(
+        model="gemma3:12b",
+        messages=[{"role": "user", "content": "Say something cool!"}]
+    )
+    print("Async response:", result.choices[0].message.content)
+
+asyncio.run(main())

gravixlayer-0.0.1/tests/test_chat_completions.py

@@ -0,0 +1,54 @@
+import unittest
+from unittest.mock import MagicMock
+from gravixlayer.client import GravixLayer
+
+class TestChatCompletions(unittest.TestCase):
+    def setUp(self):
+        self.client = GravixLayer(api_key="x")
+        self.client._make_request = MagicMock()
+        self.mock_response = MagicMock()
+        self.mock_response.json.return_value = {
+            "id": "chatcmpl-1",
+            "object": "chat.completion",
+            "created": 1234567890,
+            "model": "lorem-llama",
+            "choices": [{
+                "index": 0,
+                "message": {"role": "assistant", "content": "Hello!"},
+                "finish_reason": "stop"
+            }],
+            "usage": {"prompt_tokens": 5, "completion_tokens": 2, "total_tokens": 7}
+        }
+        self.client._make_request.return_value = self.mock_response
+
+    def test_completion_create(self):
+        chat = self.client.chat.completions
+        result = chat.create(model="lorem-llama", messages=[{"role": "user", "content": "Hi"}])
+        self.assertEqual(result.choices[0].message.content, "Hello!")
+
+    def test_optional_parameters(self):
+        chat = self.client.chat.completions
+        chat.create(
+            model="abc", messages=[], temperature=0.5, top_p=0.7, max_tokens=10,
+            frequency_penalty=0.2, presence_penalty=0.3
+        )
+        call = self.client._make_request.call_args
+        data_sent = call.args[2]  # data is always the third positional argument
+        assert data_sent["temperature"] == 0.5
+        assert data_sent["top_p"] == 0.7
+        assert data_sent["max_tokens"] == 10
+
+
+    def test_streaming_response(self):
+        # Stream mock: returns bytes like HTTP event-stream
+        lines = [
+            b'data: {"id":"chunk","choices":[{"message":{"role":"assistant","content":"Hey"},"index":0,"finish_reason":null}]}\n',
+            b'data: [DONE]\n'
+        ]
+        mock_stream_response = MagicMock()
+        mock_stream_response.iter_lines.return_value = lines
+        self.client._make_request.return_value = mock_stream_response
+
+        chat = self.client.chat.completions
+        chunks = list(chat.create(model="x", messages=[], stream=True))
+        self.assertEqual(chunks[0].choices[0].message.content, "Hey")

gravixlayer-0.0.1/tests/test_client.py

@@ -0,0 +1,18 @@
+import os
+import unittest
+from gravixlayer.client import GravixLayer
+
+class TestGravixLayerClient(unittest.TestCase):
+    def test_api_key_argument(self):
+        client = GravixLayer(api_key="test-key")
+        self.assertEqual(client.api_key, "test-key")
+    
+    def test_api_key_env(self):
+        os.environ["GRAVIXLAYER_API_KEY"] = "env-key"
+        client = GravixLayer()
+        self.assertEqual(client.api_key, "env-key")
+        del os.environ["GRAVIXLAYER_API_KEY"]
+
+    def test_https_enforcement(self):
+        with self.assertRaises(ValueError):
+            GravixLayer(api_key="k", base_url="http://not-secure.com")

gravixlayer-0.0.1/tests/test_exceptions.py

@@ -0,0 +1,24 @@
+import unittest
+from gravixlayer.client import GravixLayer
+from gravixlayer.types.exceptions import (
+    GravixLayerAuthenticationError, GravixLayerRateLimitError, GravixLayerServerError,
+    GravixLayerBadRequestError, GravixLayerConnectionError
+)
+
+class TestExceptionHandling(unittest.TestCase):
+    def setUp(self):
+        self.client = GravixLayer(api_key="x")
+
+    def test_auth_error(self):
+        def fail_auth(*a, **k):
+            raise GravixLayerAuthenticationError("bad key")
+        self.client._make_request = fail_auth
+        with self.assertRaises(GravixLayerAuthenticationError):
+            self.client.chat.completions.create(model="x", messages=[])
+
+    def test_rate_limit_error(self):
+        def fail_limit(*a, **k):
+            raise GravixLayerRateLimitError("Too many requests")
+        self.client._make_request = fail_limit
+        with self.assertRaises(GravixLayerRateLimitError):
+            self.client.chat.completions.create(model="x", messages=[])

gravixlayer-0.0.1/version.py

@@ -0,0 +1,18 @@
+"""Version information for GravixLayer SDK"""
+
+__version__ = "0.0.1"
+__version_info__ = tuple(int(x) for x in __version__.split('.'))
+
+# Version history
+VERSION_HISTORY = {
+    "0.0.1": "Initial release with OpenAI compatibility",
+    # Add future versions here
+}
+
+def get_version_info():
+    """Get current version information"""
+    return {
+        "version": __version__,
+        "version_info": __version_info__,
+        "description": VERSION_HISTORY.get(__version__, "No description available")
+    }