euriai 0.4__py3-none-any.whl → 1.0.0__py3-none-any.whl

{euriai-0.4.dist-info → euriai-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euriai
-Version: 0.4
+Version: 1.0.0
 Summary: Python client for Euri API (euron.one) with CLI, LangChain, and LlamaIndex integration
 Author: Euri
 Author-email: tech@euron.one

euriai-1.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+euriai/__init__.py,sha256=5AFG_ovSriY5Kfz0kb1uKuNK_ei6o4k-kcCgoTZqNk0,795
+euriai/autogen.py,sha256=4YAHrY65YYOKVsBjQa9G8pr-_Xxss1uR08qLAFzo7Rk,16023
+euriai/cli.py,sha256=hF1wiiL2QQSfWf8WlLQyNVDBd4YkbiwmMSoPxVbyPTM,3290
+euriai/client.py,sha256=L-o6hv9N3md-l-hz-kz5nYVaaZqnrREZlo_0jguhF7E,4066
+euriai/crewai.py,sha256=stnwsChy4MYXwWP6JBk_twg61EZTaTj8zoBiLN5n_I0,7135
+euriai/embedding.py,sha256=uP66Ph1k9Ou6J5RAkztJxlfyj0S0MESOvZ4ulhnVo-o,1270
+euriai/euri_chat.py,sha256=DEAiet1ReRwB4ljkPYaTl1Nb5uc20-JF-3PQjGQZXk4,3567
+euriai/euri_embed.py,sha256=VE-RLUb5bYnEFA_dxFkj2c3Jr_SYyJKPmFOzsDOR0Ys,2137
+euriai/langchain.py,sha256=ZHET7cO9CslXIMSKFYcjwCLWfP8pov22Udal5gSMOoo,29640
+euriai/langgraph.py,sha256=sw9e-PnfwAwmp_tUCnAGIUB78GyJsMkAzxOGvFUafiM,34128
+euriai/llamaindex.py,sha256=c-ujod2bjL6QIvfAyuIxm1SvSCS00URFElYybKQ5Ew0,26551
+euriai/n8n.py,sha256=hjkckqyW_hZNL78UkBCof1WvKCKCIjwdvZdAgx6NrB8,3764
+euriai/smolagents.py,sha256=xlixGx2IWzAPTpSJGsYIK2L-SHGY9Mw1-8GbwVsEYtU,28507
+euriai-1.0.0.dist-info/METADATA,sha256=3qQs4Z403ImXKfKnzI3__uftPhwdd_MSEFyT9rn5iPA,6881
+euriai-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+euriai-1.0.0.dist-info/entry_points.txt,sha256=9OkET8KIGcsjQn8UlnpPKRT75s2KW34jq1__1SXtpMA,43
+euriai-1.0.0.dist-info/top_level.txt,sha256=TG1htJ8cuD62MXn-NJ7DVF21QHY16w6M_QgfF_Er_EQ,7
+euriai-1.0.0.dist-info/RECORD,,

euriai/euri_autogen.py

@@ -1,74 +0,0 @@
-from typing import Optional, Dict, Any, List
-
-try:
-    import autogen
-except ImportError:
-    autogen = None
-
-class EuriaiAutoGen:
-    """
-    Full-featured wrapper for AutoGen integration in the EURI SDK.
-    Allows programmatic agent, tool, and workflow management, and chat execution.
-    """
-    def __init__(self, config: Optional[Dict[str, Any]] = None):
-        """
-        Initialize the AutoGen wrapper.
-        Args:
-            config: Dict of config options (API keys, model, etc.)
-        """
-        if autogen is None:
-            raise ImportError("AutoGen is not installed. Please install with `pip install pyautogen`.")
-        self.config = config or {}
-        self.agents: List[Any] = []
-        self.tools: List[Any] = []
-        self.memory: Optional[Any] = None
-        self.workflow: Optional[Any] = None
-        self.history: List[Dict[str, Any]] = []
-
-    def add_agent(self, agent_config: Dict[str, Any]) -> Any:
-        """Add an agent with config."""
-        agent = autogen.Agent(**agent_config)
-        self.agents.append(agent)
-        return agent
-
-    def add_tool(self, tool_config: Dict[str, Any]) -> Any:
-        """Add a tool with config."""
-        tool = autogen.Tool(**tool_config)
-        self.tools.append(tool)
-        return tool
-
-    def set_memory(self, memory_config: Dict[str, Any]) -> None:
-        """Set memory for the workflow."""
-        self.memory = autogen.Memory(**memory_config)
-
-    def run_chat(self, prompt: str, agent_idx: int = 0, **kwargs) -> str:
-        """
-        Run a chat with the specified agent and prompt.
-        Returns the agent's response.
-        """
-        if not self.agents:
-            raise ValueError("No agents defined. Use add_agent().")
-        agent = self.agents[agent_idx]
-        response = agent.chat(prompt, **kwargs)
-        self.history.append({"agent": agent, "prompt": prompt, "response": response})
-        return response
-
-    def run_workflow(self, workflow_config: Dict[str, Any], **kwargs) -> Any:
-        """
-        Run a custom workflow (advanced usage).
-        """
-        workflow = autogen.Workflow(**workflow_config)
-        self.workflow = workflow
-        result = workflow.run(**kwargs)
-        return result
-
-    def get_history(self) -> List[Dict[str, Any]]:
-        return self.history
-
-    def reset(self):
-        """Reset agents, tools, memory, and history."""
-        self.agents = []
-        self.tools = []
-        self.memory = None
-        self.workflow = None
-        self.history = [] 

euriai/euri_crewai.py

@@ -1,92 +0,0 @@
-import os
-from typing import Optional, Dict, Any, List, Union
-
-# CrewAI imports (user must install crewai)
-try:
-    from crewai import Agent, Crew, Task, Process
-except ImportError:
-    Agent = Crew = Task = Process = None
-
-class EuriaiCrewAI:
-    """
-    Full-featured wrapper for CrewAI integration in the EURI SDK.
-    Allows programmatic and config-based crew creation, agent/task management, and workflow execution.
-    """
-    def __init__(self, agents: Optional[Dict[str, Any]] = None, tasks: Optional[Dict[str, Any]] = None, process: str = "sequential", verbose: bool = True):
-        """
-        Initialize the CrewAI wrapper.
-        Args:
-            agents: Dict of agent configs or Agent objects.
-            tasks: Dict of task configs or Task objects.
-            process: 'sequential' or 'parallel'.
-            verbose: Print detailed logs.
-        """
-        if Agent is None:
-            raise ImportError("CrewAI is not installed. Please install with `pip install crewai`.")
-        self.agents_config = agents or {}
-        self.tasks_config = tasks or {}
-        self.process = Process.sequential if process == "sequential" else Process.parallel
-        self.verbose = verbose
-        self._agents: List[Agent] = []
-        self._tasks: List[Task] = []
-        self._crew: Optional[Crew] = None
-
-    def add_agent(self, name: str, config: Dict[str, Any]) -> None:
-        """Add an agent by config."""
-        agent = Agent(**config)
-        self._agents.append(agent)
-        self.agents_config[name] = config
-
-    def add_task(self, name: str, config: Dict[str, Any]) -> None:
-        """Add a task by config."""
-        task = Task(**config)
-        self._tasks.append(task)
-        self.tasks_config[name] = config
-
-    def build_crew(self) -> Crew:
-        """Build the Crew object from current agents and tasks."""
-        if not self._agents:
-            self._agents = [Agent(**cfg) for cfg in self.agents_config.values()]
-        if not self._tasks:
-            self._tasks = [Task(**cfg) for cfg in self.tasks_config.values()]
-        self._crew = Crew(agents=self._agents, tasks=self._tasks, process=self.process, verbose=self.verbose)
-        return self._crew
-
-    def run(self, inputs: Optional[Dict[str, Any]] = None) -> Any:
-        """
-        Run the crew workflow. Optionally pass input variables for tasks.
-        Returns the final result or report.
-        """
-        if self._crew is None:
-            self.build_crew()
-        return self._crew.kickoff(inputs=inputs or {})
-
-    @classmethod
-    def from_yaml(cls, agents_yaml: str, tasks_yaml: str, process: str = "sequential", verbose: bool = True):
-        """
-        Create a CrewAI wrapper from YAML config files.
-        Args:
-            agents_yaml: Path to agents.yaml
-            tasks_yaml: Path to tasks.yaml
-        """
-        import yaml
-        with open(agents_yaml, "r") as f:
-            agents = yaml.safe_load(f)
-        with open(tasks_yaml, "r") as f:
-            tasks = yaml.safe_load(f)
-        return cls(agents=agents, tasks=tasks, process=process, verbose=verbose)
-
-    def get_agents(self) -> List[Agent]:
-        return self._agents
-
-    def get_tasks(self) -> List[Task]:
-        return self._tasks
-
-    def get_crew(self) -> Optional[Crew]:
-        return self._crew
-
-    def reset(self):
-        """Reset agents, tasks, and crew."""
-        self._agents = []
-        self._tasks = []
-        self._crew = None 

euriai/euri_langgraph.py

@@ -1,64 +0,0 @@
-from typing import Any, Callable, Dict, List, Optional, Union
-
-try:
-    from langgraph.graph import StateGraph
-except ImportError:
-    StateGraph = None
-
-class EuriaiLangGraph:
-    """
-    Full-featured wrapper for LangGraph integration in the EURI SDK.
-    Allows programmatic graph construction, node/edge management, and workflow execution.
-    """
-    def __init__(self, name: str = "EuriaiLangGraph", state: Optional[Dict[str, Any]] = None):
-        """
-        Initialize the LangGraph wrapper.
-        Args:
-            name: Name of the graph.
-            state: Initial state dictionary.
-        """
-        if StateGraph is None:
-            raise ImportError("LangGraph is not installed. Please install with `pip install langgraph`.")
-        self.name = name
-        self.state = state or {}
-        self.graph = StateGraph()
-        self.nodes: Dict[str, Callable] = {}
-        self.edges: List[tuple] = []
-
-    def add_node(self, node_name: str, node_fn: Callable) -> None:
-        """Add a node to the graph."""
-        self.graph.add_node(node_name, node_fn)
-        self.nodes[node_name] = node_fn
-
-    def add_edge(self, from_node: str, to_node: str) -> None:
-        """Add an edge between two nodes."""
-        self.graph.add_edge(from_node, to_node)
-        self.edges.append((from_node, to_node))
-
-    def set_state(self, state: Dict[str, Any]) -> None:
-        """Set the initial state for the graph execution."""
-        self.state = state
-
-    def run(self, input_state: Optional[Dict[str, Any]] = None, **kwargs) -> Any:
-        """
-        Run the graph workflow with the given state.
-        Returns the final state/output.
-        """
-        state = input_state or self.state
-        return self.graph.run(state, **kwargs)
-
-    def get_nodes(self) -> Dict[str, Callable]:
-        return self.nodes
-
-    def get_edges(self) -> List[tuple]:
-        return self.edges
-
-    def get_graph(self) -> Any:
-        return self.graph
-
-    def reset(self):
-        """Reset the graph, nodes, and edges."""
-        self.graph = StateGraph()
-        self.nodes = {}
-        self.edges = []
-        self.state = {} 

euriai/euri_llamaindex.py

@@ -1,58 +0,0 @@
-from typing import Optional, List, Any, Dict, Union
-
-try:
-    from llama_index.core import VectorStoreIndex, ServiceContext
-    from llama_index.core.llms import LLM
-    from llama_index.core.schema import Document
-except ImportError:
-    VectorStoreIndex = ServiceContext = LLM = Document = None
-
-class EuriaiLlamaIndex:
-    """
-    Full-featured wrapper for LlamaIndex integration in the EURI SDK.
-    Allows document ingestion, index building, and querying with advanced config.
-    """
-    def __init__(self, llm: Optional[Any] = None, service_context: Optional[Any] = None):
-        """
-        Initialize the LlamaIndex wrapper.
-        Args:
-            llm: LLM object (optional)
-            service_context: ServiceContext object (optional)
-        """
-        if VectorStoreIndex is None:
-            raise ImportError("LlamaIndex is not installed. Please install with `pip install llama_index`.")
-        self.llm = llm
-        self.service_context = service_context or (ServiceContext.from_defaults(llm=llm) if llm else ServiceContext.from_defaults())
-        self.index: Optional[Any] = None
-        self.documents: List[Any] = []
-
-    def add_documents(self, docs: List[Union[str, Dict[str, Any]]]) -> None:
-        """Add documents (as strings or dicts) to the index."""
-        for doc in docs:
-            if isinstance(doc, str):
-                self.documents.append(Document(text=doc))
-            elif isinstance(doc, dict):
-                self.documents.append(Document(**doc))
-            else:
-                raise ValueError("Document must be str or dict.")
-
-    def build_index(self) -> None:
-        """Build the vector index from current documents."""
-        self.index = VectorStoreIndex.from_documents(self.documents)
-
-    def query(self, query: str, **kwargs) -> Any:
-        """
-        Query the index with a string. Returns the response object.
-        """
-        if self.index is None:
-            self.build_index()
-        query_engine = self.index.as_query_engine(service_context=self.service_context)
-        return query_engine.query(query, **kwargs)
-
-    def get_index(self) -> Optional[Any]:
-        return self.index
-
-    def reset(self):
-        """Reset documents and index."""
-        self.documents = []
-        self.index = None 

euriai/euri_n8n.py

@@ -1,30 +0,0 @@
-import requests
-from typing import Any, Dict, Optional
-
-class EuriaiN8N:
-    """
-    Wrapper for n8n workflow automation integration in the EURI SDK.
-    Allows triggering n8n workflows and exchanging data via REST API.
-    """
-    def __init__(self, base_url: str, api_key: Optional[str] = None):
-        """
-        Initialize the n8n wrapper.
-        Args:
-            base_url: Base URL of the n8n instance (e.g., http://localhost:5678 or cloud URL)
-            api_key: Optional API key for authentication
-        """
-        self.base_url = base_url.rstrip('/')
-        self.api_key = api_key
-
-    def trigger_workflow(self, workflow_id: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """
-        Trigger an n8n workflow by ID, optionally passing data.
-        Returns the workflow execution response.
-        """
-        url = f"{self.base_url}/webhook/{workflow_id}"
-        headers = {}
-        if self.api_key:
-            headers["Authorization"] = f"Bearer {self.api_key}"
-        response = requests.post(url, json=data or {}, headers=headers)
-        response.raise_for_status()
-        return response.json() 

euriai/euri_smolagents.py

@@ -1,44 +0,0 @@
-from typing import Any, Callable, Dict, List, Optional
-
-try:
-    from smolagents import CodeAgent, HfApiModel, tool
-except ImportError:
-    CodeAgent = HfApiModel = tool = None
-
-class EuriaiSmolAgent:
-    """
-    Full-featured wrapper for SmolAgents integration in the EURI SDK.
-    Allows agent creation, tool integration, and task execution.
-    """
-    def __init__(self, model: Optional[Any] = None, tools: Optional[List[Callable]] = None):
-        """
-        Initialize the SmolAgent wrapper.
-        Args:
-            model: LLM model (default: HfApiModel())
-            tools: List of tool functions (decorated with @tool)
-        """
-        if CodeAgent is None:
-            raise ImportError("SmolAgents is not installed. Please install with `pip install smolagents`.")
-        self.model = model or HfApiModel()
-        self.tools = tools or []
-        self.agent = CodeAgent(tools=self.tools, model=self.model)
-
-    def add_tool(self, tool_fn: Callable) -> None:
-        """Add a tool to the agent."""
-        self.tools.append(tool_fn)
-        self.agent = CodeAgent(tools=self.tools, model=self.model)
-
-    def run(self, prompt: str, **kwargs) -> Any:
-        """
-        Run the agent on a prompt/task.
-        Returns the agent's response.
-        """
-        return self.agent.run(prompt, **kwargs)
-
-    def get_agent(self) -> Any:
-        return self.agent
-
-    def reset(self):
-        """Reset the agent and tools."""
-        self.tools = []
-        self.agent = CodeAgent(tools=self.tools, model=self.model) 

euriai/langchain_embed.py

@@ -1,17 +0,0 @@
-try:
-    from langchain_core.embeddings import Embeddings
-except ImportError:
-    raise ImportError("LangChain is not installed. Please install with 'pip install euriai[langchain]' or 'pip install langchain'.")
-from typing import List
-from euriai.embedding import EuriaiEmbeddingClient
-
-
-class EuriaiEmbeddings(Embeddings):
-    def __init__(self, api_key: str, model: str = "text-embedding-3-small"):
-        self.client = EuriaiEmbeddingClient(api_key=api_key, model=model)
-
-    def embed_documents(self, texts: List[str]) -> List[List[float]]:
-        return [embedding.tolist() for embedding in self.client.embed_batch(texts)]
-
-    def embed_query(self, text: str) -> List[float]:
-        return self.client.embed(text).tolist()

euriai/langchain_llm.py

@@ -1,29 +0,0 @@
-try:
-    from langchain.llms.base import LLM
-except ImportError:
-    raise ImportError("LangChain is not installed. Please install with 'pip install euriai[langchain]' or 'pip install langchain'.")
-from typing import Optional, List
-from euriai import EuriaiClient
-
-
-class EuriaiLangChainLLM(LLM):
-    model: str = "gpt-4.1-nano"
-    temperature: float = 0.7
-    max_tokens: int = 300
-
-    def __init__(self, api_key: str, model: str = "gpt-4.1-nano", temperature: float = 0.7, max_tokens: int = 300, **kwargs):
-        super().__init__(model=model, temperature=temperature, max_tokens=max_tokens, **kwargs)
-        object.__setattr__(self, "_client", EuriaiClient(api_key=api_key, model=model))
-
-    @property
-    def _llm_type(self) -> str:
-        return "euriai"
-
-    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
-        response = self._client.generate_completion(
-            prompt=prompt,
-            temperature=self.temperature,
-            max_tokens=self.max_tokens,
-            stop=stop
-        )
-        return response.get("choices", [{}])[0].get("message", {}).get("content", "")

euriai-0.4.dist-info/RECORD

@@ -1,19 +0,0 @@
-euriai/__init__.py,sha256=JaXTVZFPARYHzpICgl-F5hd5OCYcwG0IOdTXV4wsrK4,835
-euriai/cli.py,sha256=hF1wiiL2QQSfWf8WlLQyNVDBd4YkbiwmMSoPxVbyPTM,3290
-euriai/client.py,sha256=L-o6hv9N3md-l-hz-kz5nYVaaZqnrREZlo_0jguhF7E,4066
-euriai/embedding.py,sha256=uP66Ph1k9Ou6J5RAkztJxlfyj0S0MESOvZ4ulhnVo-o,1270
-euriai/euri_autogen.py,sha256=OSrQJbbPXXgZ5bubofxnvq-dabs8B8G2dfSHn-LCbw0,2515
-euriai/euri_chat.py,sha256=DEAiet1ReRwB4ljkPYaTl1Nb5uc20-JF-3PQjGQZXk4,3567
-euriai/euri_crewai.py,sha256=1Z_lqHr4Jn0mt7jTsh8JXWdjpC_q1AhN-Mm6PDigG10,3443
-euriai/euri_embed.py,sha256=VE-RLUb5bYnEFA_dxFkj2c3Jr_SYyJKPmFOzsDOR0Ys,2137
-euriai/euri_langgraph.py,sha256=x8RNSrdcCzY6AunNNHzeX3297srecNUwHdDLTrBb1u8,2131
-euriai/euri_llamaindex.py,sha256=AVBgfm_cQiZEpfcIAcMeIs55eW_SvDPJPZ31Y_blN0I,2281
-euriai/euri_n8n.py,sha256=8JvEgvq14ZI7k5_Rfimpbht4RtYSwMh2gKyo1H4Wl6M,1148
-euriai/euri_smolagents.py,sha256=RcxwI9coXF_DmIy_0TqEF737CIIpZn8f0p_9G5rSFpY,1530
-euriai/langchain_embed.py,sha256=9nZgD_99CCpsGvXpLUW-Gklxp-pJ4IMhO8ZfbesqLyI,749
-euriai/langchain_llm.py,sha256=BKNg1i48EAciEXyBVK7_Y9glkhLGWF_OfkKPzvnLtB0,1151
-euriai-0.4.dist-info/METADATA,sha256=G0fouJYynkW0KG8mcqABkL5TKbEoLLwAJSInBSOgHxg,6879
-euriai-0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-euriai-0.4.dist-info/entry_points.txt,sha256=9OkET8KIGcsjQn8UlnpPKRT75s2KW34jq1__1SXtpMA,43
-euriai-0.4.dist-info/top_level.txt,sha256=TG1htJ8cuD62MXn-NJ7DVF21QHY16w6M_QgfF_Er_EQ,7
-euriai-0.4.dist-info/RECORD,,