py-client-cap 0.1.7__py3-none-any.whl

py_client_cap/__init__.py

@@ -0,0 +1,4 @@
+from .crud_php_api      import CrudPHPApi
+from .crud_php_table    import CrudPHPTable
+from .manager           import CrudPHPDB
+from .models            import *

py_client_cap/crud_php_api.py

@@ -0,0 +1,143 @@
+import requests
+from dataclasses import dataclass, asdict
+from typing import Optional, Dict, Any, List
+from .models import ApiResponse, Item, Column, Table
+
+class CrudPHPApi:
+    def __init__(self, base_url: str, api_key: Optional[str] = None, timeout: int = 10):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.session = requests.Session()
+        default_headers = {
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.95 Safari/537.36',
+            'Content-Type': 'application/json',
+            'Accept': 'application/json'
+        }
+        if api_key:
+            default_headers['Authorization'] = f"Bearer {api_key}"
+            default_headers['X-App-Token'] = api_key
+        self.session.headers.update(default_headers)
+
+    def _request(self, method: str, endpoint: str, data: Optional[Dict] = None, params: Optional[Dict] = None, headers: Optional[Dict] = None) -> ApiResponse:
+        url = f"{self.base_url}/{endpoint.lstrip('/')}"
+        try:
+            kwargs = {
+                "method": method.upper(),
+                "url": url,
+                "json": data,
+                "params": params,
+                "timeout": self.timeout
+            }
+            if headers is not None:
+                kwargs["headers"] = headers
+            res = self.session.request(**kwargs)            
+            try:
+                payload = res.json() if res.content else None
+            except ValueError:
+                payload = res.text
+            if res.ok:
+                return ApiResponse(status_code=res.status_code, success=True, data=payload)
+            else:
+                error_msg = payload.get("message") if isinstance(payload, dict) and "message" in payload else res.text
+                return ApiResponse(status_code=res.status_code, success=False, error=error_msg, raw_response=payload)
+        except requests.exceptions.RequestException as err:
+            return ApiResponse(status_code=0, success=False, error=f"Connection Error: {str(err)}")
+
+    def create(self, endpoint: str, payload: Dict[str, Any], headers: Optional[Dict] = None) -> ApiResponse: 
+        return self._request("POST", endpoint, data=payload, headers=headers)
+    
+    def read(self, endpoint: str, item_id: Optional[int] = None, query_params: Optional[Dict] = None, headers: Optional[Dict] = None) -> ApiResponse: 
+        return self._request("GET", f"{endpoint}/{item_id}" if item_id else endpoint, params=query_params, headers=headers)
+    
+    def update(self, endpoint: str, item_id: int, payload: Dict[str, Any], headers: Optional[Dict] = None) -> ApiResponse: 
+        return self._request("PUT", f"{endpoint}/{item_id}", data=payload, headers=headers)
+    
+    def delete(self, endpoint: str, item_id: int, headers: Optional[Dict] = None) -> ApiResponse: 
+        return self._request("DELETE", f"{endpoint}/{item_id}", headers=headers)
+    
+    def export_table_structure(self, openapi_endpoint: str, table_name: str) -> ApiResponse:
+        response = self.read(openapi_endpoint)
+        if not response.success:
+            return response
+        
+        openapi_data = response.data
+        if not isinstance(openapi_data, dict):
+            return ApiResponse(status_code=400, success=False, error="Invalid OpenAPI response")
+        
+        schemas = openapi_data.get("components", {}).get("schemas", {})
+        
+        table_schema = schemas.get(table_name)
+        if not table_schema:
+            table_schema = schemas.get(f"read-{table_name}")
+        if not table_schema:
+            list_schema = schemas.get(f"list-{table_name}")
+            if list_schema:
+                table_schema = list_schema.get("properties", {}).get("records", {}).get("items", {})
+
+        if not table_schema or "properties" not in table_schema:
+            return ApiResponse(status_code=404, success=False, error=f"Table schema for '{table_name}' not found in OpenAPI specification")
+        
+        properties = table_schema["properties"]
+        columns = []
+        init_params = []
+        
+        for col_name, col_details in properties.items():
+            openapi_type = col_details.get("type", "string")
+            type_mapping = {
+                "integer": "int",
+                "number": "float",
+                "boolean": "bool",
+                "string": "str"
+            }
+            py_type = type_mapping.get(openapi_type, "str")
+            
+            default_value = col_details.get("default")
+            
+            if default_value is not None:
+                if py_type == "str":
+                    default_repr = f"'{default_value}'"
+                else:
+                    default_repr = str(default_value)
+                init_param = f"{col_name}: {py_type} = {default_repr}"
+            else:
+                fallback = "''" if py_type == "str" else ("0" if py_type in ["int", "float"] else "False")
+                init_param = f"{col_name}: {py_type} = {fallback}"
+                
+            columns.append(Column(name=col_name, data_type=py_type))
+            init_params.append(init_param)
+        
+        class_name = f"{table_name.capitalize()}Table"
+        class_body = f"class {class_name}:\n"
+        for column in columns:
+            class_body += f"    {column.name}: {column.data_type}\n"
+            
+        class_body += "    def __init__(self, " + ', '.join(init_params) + "):\n"
+        init_assignments = [f"self.{column.name} = {column.name}" for column in columns]
+        class_body += "        " + "\n        ".join(init_assignments) + "\n"
+        
+        class_body += "\n    def to_dict(self) -> Dict[str, Any]:\n"
+        class_body += "        return {\n"
+        for column in columns:
+            class_body += f"            '{column.name}': self.{column.name},\n"
+        class_body += "        }"
+        
+        return ApiResponse(status_code=200, success=True, data={
+            "class_name": class_name,
+            "class_body": class_body
+        })
+
+    def list_tables(self) -> List[str]:
+        """Estrae e normalizza la lista univoca di tutte le tabelle dai path OpenAPI."""
+        response = self.read('openapi')
+        
+        if not response.success or not isinstance(response.data, dict):
+            return []
+        
+        paths = response.data.get("paths", {})
+        tables = set()
+        for path in paths.keys():
+            parts = path.strip("/").split("/")
+            if len(parts) >= 2 and parts[0] == "records":
+                tables.add(parts[1])
+                
+        return sorted(list(tables))

py_client_cap/crud_php_table.py

@@ -0,0 +1,87 @@
+from typing import Optional, Dict, Any, List, Union
+from .models import ApiResponse
+from py_client_cap import CrudPHPApi 
+
+class CrudPHPTable(CrudPHPApi):
+    def __init__(self, base_url: str, table_name: str, api_key: Optional[str] = None, timeout: int = 10):
+        super().__init__(base_url=base_url, api_key=api_key, timeout=timeout)
+        self.table_name = table_name.strip("/")
+        self.last_total_count: Optional[int] = None
+
+    def _build_table_endpoint(self, action_path: str = "") -> str:
+        parts = ["records", self.table_name]
+        if action_path:
+            parts.append(str(action_path).lstrip("/"))
+        return "/".join(parts)
+
+    def list_rows(
+        self, 
+        filters: Optional[Union[str, List[str]]] = None, 
+        logic: str = "and",  # "and" oppure "or"
+        order: Optional[Union[str, List[str]]] = None, 
+        page: Optional[int] = None, 
+        size: Optional[int] = None, 
+        query_params: Optional[Dict[str, Any]] = None, 
+        headers: Optional[Dict[str, str]] = None
+    ) -> ApiResponse:
+        endpoint = self._build_table_endpoint()
+        params = dict(query_params) if query_params else {}
+
+        if filters:
+            if isinstance(filters, list):
+                if logic.lower() == "or":
+                    for i, f in enumerate(filters, start=1):
+                        params[f"filter{i}"] = f
+                else:
+                    params["filter[]"] = filters
+            else:
+                params["filter"] = filters
+
+        if order:
+            if isinstance(order, list):
+                params["order[]"] = order
+            else:
+                params["order"] = order
+
+        if page is not None:
+            params["page"] = page
+        if size is not None:
+            params["size"] = size
+
+        response = self._request("GET", endpoint, params=params, headers=headers)
+        
+        # --- PARTE CORRETTA ---
+        if response.success and isinstance(response.data, dict):
+            # Prima verifica se c'è la chiave metadata "results" (totale assoluto)
+            if "results" in response.data:
+                self.last_total_count = response.data.get("results")
+            else:
+                # Fallback: conta i record fisici ricevuti nella pagina
+                records = response.data.get("records")
+                if isinstance(records, list):
+                    self.last_total_count = len(records)
+                else:
+                    self.last_total_count = 0
+        elif response.success and isinstance(response.data, list):
+            self.last_total_count = len(response.data)
+            
+        return response
+        
+    def get_row(self, row_id: Any, query_params: Optional[Dict] = None, headers: Optional[Dict] = None) -> ApiResponse:
+        endpoint = self._build_table_endpoint(row_id)
+        return self._request("GET", endpoint, params=query_params, headers=headers)
+
+    def insert_row(self, payload: Dict[str, Any], headers: Optional[Dict] = None) -> ApiResponse:
+        endpoint = self._build_table_endpoint()
+        return self._request("POST", endpoint, data=payload, headers=headers)
+
+    def update_row(self, row_id: Any, payload: Dict[str, Any], headers: Optional[Dict] = None) -> ApiResponse:
+        endpoint = self._build_table_endpoint(row_id)
+        return self._request("PUT", endpoint, data=payload, headers=headers)
+
+    def delete_row(self, row_id: Any, headers: Optional[Dict] = None) -> ApiResponse:
+        endpoint = self._build_table_endpoint(row_id)
+        return self._request("DELETE", endpoint, headers=headers)
+    
+    def to_class(self, headers: Optional[Dict] = None) -> ApiResponse:
+        return self.export_table_structure('openapi', self.table_name)

py_client_cap/manager.py

@@ -0,0 +1,28 @@
+from typing import List, Optional
+from py_client_cap import CrudPHPApi, CrudPHPTable
+
+class CrudPHPDB:
+    def __init__(self, base_url: str, api_key: Optional[str] = None, timeout: int = 10):
+        self.api = CrudPHPApi(base_url=base_url, api_key=api_key, timeout=timeout)
+        self._tables_cache: Optional[List[str]] = None
+        self._base_url = base_url
+        self._api_key = api_key
+        self._timeout = timeout
+
+    def list_tables(self) -> List[str]:
+        if self._tables_cache is None:
+            self._tables_cache = self.api.list_tables()
+        return self._tables_cache
+
+    def table(self, table_name: str, raise_if_not_found: bool = False) -> Optional[CrudPHPTable]:
+        tables = self.list_tables()
+        if table_name not in tables:
+            if raise_if_not_found:
+                raise KeyError(f"La tabella '{table_name}' non è stata trovata.")
+            return None
+        return CrudPHPTable(
+            base_url=self._base_url,
+            table_name=table_name,
+            api_key=self._api_key,
+            timeout=self._timeout
+        )

py_client_cap/models/__init__.py

@@ -0,0 +1,4 @@
+from .item           import Item
+from .apiresponse    import ApiResponse
+from .column         import Column
+from .table          import Table

py_client_cap/models/apiresponse.py

@@ -0,0 +1,18 @@
+from typing import Optional, Dict, Any
+from dataclasses import dataclass, asdict
+
+@dataclass
+class ApiResponse:
+    status_code: int
+    success: bool
+    data: Optional[Any] = None
+    error: Optional[str] = None
+    raw_response: Optional[Dict] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "status_code": self.status_code,
+            "success": self.success,
+            "data": self.data,
+            "error": self.error
+        }

py_client_cap/models/column.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+from typing import Any, Optional
+
+@dataclass
+class Column:
+    name: str
+    data_type: str
+    default: Optional[Any] = None

py_client_cap/models/item.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass, asdict
+from typing import Optional
+
+@dataclass
+class Item:
+    id: Optional[int] = None
+    title: str = ""
+    description: str = ""
+    status: str = "active"
+
+    def to_dict(self):
+        return {k: v for k, v in asdict(self).items() if v is not None}

py_client_cap/models/table.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+from typing import Any, List, Optional
+from .column        import Column
+
+@dataclass
+class Table:
+    name: str
+    columns: List[Column]
+    
+    def export_table_structure(self) -> str:
+        # Implementazione della funzione per esportare la struttura della tabella
+        class_name = f"{self.name.capitalize()}Table"
+        class_body = f"class {class_name}:\n"
+        
+        # Aggiungi gli attributi delle colonne
+        for column in self.columns:
+            class_body += f"    {column.name}: {column.data_type}\n"
+
+        # Aggiungi il metodo per creare un oggetto della tabella
+        class_body += "    def __init__(self, " + ', '.join([f"{column.name}: {column.data_type}" for column in self.columns]) + "):\n"
+        class_body += "        self." + ', '.join([f"{column.name} = {column.name}" for column in self.columns])
+
+        # Aggiungi il metodo per esportare la struttura della tabella
+        class_body += "\n    def to_dict(self) -> Dict[str, Any]:\n"
+        class_body += "        return {\n"
+        for column in self.columns:
+            class_body += f"            '{column.name}': self.{column.name},\n"
+        class_body += "        }"
+        
+        return class_body

py_client_cap-0.1.7.dist-info/METADATA

@@ -0,0 +1,228 @@
+Metadata-Version: 2.4
+Name: py_client_cap
+Version: 0.1.7
+Summary: Client Python e libreria REST API per la gestione automatizzata di database tramite backend PHP CRUD (codice su Git). Integrazione rapida via HTTP e JSON
+Home-page: https://www.newstechnology.eu
+Author: Daniele Frulla
+Author-email: daniele.frulla@newstechnology.eu
+Keywords: python,php,crud,rest-api,database-manager,git-repo,php-crud-api
+Description-Content-Type: text/markdown
+Requires-Dist: requests==2.34.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: requires-dist
+Dynamic: summary
+
+# Libreria Python Client CRUD PHP API
+
+Questo documento racchiude tutto il necessario per utilizzare la libreria: le istruzioni d'uso (README), il codice sorgente completo e la suite di test unitari con mock.
+Le api che si andranno ad utilizzare sono quelle create con la libreria [PHPCrudApi](https://github.com/mevdschee/php-crud-api)
+
+## Installazione
+
+1. **PIP**:
+    ```python
+    pip install py_client_cap
+    ```
+## Uso
+
+### 1. Utilizzo della libreria
+
+```python
+from py_client_cap import CrudPHPDB
+
+base_url = "http://127.0.0.1:8082/modules/api/index.php"
+api_key = "test-token"
+
+db = CrudPHPDB(base_url=base_url, api_key=api_key)
+
+# Ritorna le tabelle
+tables = db.list_tables()
+
+# Usa le tabelle
+table_client = db.table( 'Tabella1', raise_if_not_found=True)
+response_records = table_client.list_rows(page=1,size=1)
+records_count = table_client.last_total_count
+
+#Il totale delle tabelle viene restituito solo se la ricerca e' con page=x
+```
+
+# Gestire le Tabelle
+
+## Classe CrudPHPTable
+
+La classe `CrudPHPTable` è stata creata per gestire le operazioni su una tabella PHP API. Questa classe estende la classe base `CrudPHPApi` e aggiunge funzionalità per elencare i record, selezionare un singolo record, inserire un nuovo record, aggiornare un record esistente e eliminare un record.
+
+### Costruttore
+
+```python
+def __init__(self, base_url: str, table_name: str, api_key: Optional[str] = None, timeout: int = 10):
+    """
+    Inizializza la classe CrudPHPTable.
+
+    Args:
+        base_url (str): URL base del server PHP API.
+        table_name (str): Nome della tabella a cui si intende accedere.
+        api_key (str, optional): Chiave API per autenticazione. Default è None.
+        timeout (int, optional): Timeout per le richieste HTTP. Default è 10.
+    """
+```
+
+### Metodi
+
+#### `_build_table_endpoint`
+
+```python
+def _build_table_endpoint(self, action_path: str = "") -> str:
+    """
+    Costruisce l'endpoint della tabella.
+
+    Args:
+        action_path (str, optional): Percorso di azione specifico. Default è None.
+
+    Returns:
+        str: Endpoint della tabella.
+    """
+```
+
+#### `list_rows`
+
+```python
+def list_rows(
+    self, 
+    filters: Optional[Union[str, List[str]]] = None, 
+    logic: str = "and",  # "and" oppure "or"
+    order: Optional[Union[str, List[str]]] = None, 
+    page: Optional[int] = None, 
+    size: Optional[int] = None, 
+    query_params: Optional[Dict[str, Any]] = None, 
+    headers: Optional[Dict[str, str]] = None
+) -> ApiResponse:
+    """
+    Effettua una richiesta GET per elencare i record della tabella.
+
+    Args:
+        filters (Union[str, List[str]], optional): Filtro da applicare alle query. Default è None.
+        logic (str, optional): Logica di filtre ("and" o "or"). Default è "and".
+        order (Union[str, List[str]], optional): Ordinamento delle risposte. Default è None.
+        page (int, optional): Pagina di risposta da ottenere. Default è None.
+        size (int, optional): Numero di record per pagina. Default è None.
+        query_params (Dict[str, Any], optional): Parametri di query. Default è None.
+        headers (Dict[str, str], optional): Header HTTP. Default è None.
+
+    Returns:
+        ApiResponse: Risposta della richiesta.
+    """
+```
+
+#### `get_row`
+
+```python
+def get_row(self, row_id: Any, query_params: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None) -> ApiResponse:
+    """
+    Effettua una richiesta GET per selezionare un singolo record della tabella.
+
+    Args:
+        row_id (Any): Identificatore del record.
+        query_params (Dict[str, Any], optional): Parametri di query. Default è None.
+        headers (Dict[str, str], optional): Header HTTP. Default è None.
+
+    Returns:
+        ApiResponse: Risposta della richiesta.
+    """
+```
+
+#### `insert_row`
+
+```python
+def insert_row(self, payload: Dict[str, Any], headers: Optional[Dict[str, str]] = None) -> ApiResponse:
+    """
+    Effettua una richiesta POST per inserire un nuovo record nella tabella.
+
+    Args:
+        payload (Dict[str, Any]): Payload del nuovo record.
+        headers (Dict[str, str], optional): Header HTTP. Default è None.
+
+    Returns:
+        ApiResponse: Risposta della richiesta.
+    """
+```
+
+#### `update_row`
+
+```python
+def update_row(self, row_id: Any, payload: Dict[str, Any], headers: Optional[Dict[str, str]] = None) -> ApiResponse:
+    """
+    Effettua una richiesta PUT per aggiornare un record esistente nella tabella.
+
+    Args:
+        row_id (Any): Identificatore del record.
+        payload (Dict[str, Any]): Payload dell'aggiornamento.
+        headers (Dict[str, str], optional): Header HTTP. Default è None.
+
+    Returns:
+        ApiResponse: Risposta della richiesta.
+    """
+```
+
+#### `delete_row`
+
+```python
+def delete_row(self, row_id: Any, headers: Optional[Dict[str, str]] = None) -> ApiResponse:
+    """
+    Effettua una richiesta DELETE per eliminare un record dalla tabella.
+
+    Args:
+        row_id (Any): Identificatore del record.
+        headers (Dict[str, str], optional): Header HTTP. Default è None.
+
+    Returns:
+        ApiResponse: Risposta della richiesta.
+    """
+```
+
+#### `to_class`
+
+```python
+def to_class(self, headers: Optional[Dict] = None) -> ApiResponse:
+    """
+    Effettua una richiesta GET per esportare la struttura della tabella in formato OpenAPI.
+
+    Args:
+        headers (Dict[str, str], optional): Header HTTP. Default è None.
+
+    Returns:
+        ApiResponse: Risposta della richiesta.
+    """
+```
+
+### Note
+
+- L'API REST è gestita automaticamente dalla classe `CrudPHPApi`, che estende `requests.Session`.
+- Il metodo `_build_table_endpoint` costruisce l'endpoint della tabella.
+- I metodi `list_rows`, `get_row`, `insert_row`, `update_row`, `delete_row` effettuano richieste HTTP GET, POST, PUT e DELETE rispettivamente.
+- Il metodo `to_class` effettua una richiesta GET per esportare la struttura della tabella in formato OpenAPI.
+- L'API REST richiede autenticazione tramite una chiave API se specificata.
+
+## Esempio di utilizzo
+
+```python
+# Importazione della classe CrudPHPTable
+from py_client_cap import CrudPHPTable
+
+# Configurazione del client
+base_url = "http://example.com/api"
+api_key = "your_api_key_here"
+
+# Creazione dell'oggetto CrudPHPTable
+table_client = CrudPHPTable(base_url=base_url, api_key=api_key)
+
+# Elenco dei record della tabella
+response = table_client.list_rows()
+print(response)
+
+Questo esempio mostra come utilizzare la classe 'CrudPHPTable' per effettuare operazioni di liste e selezione di record su una tabella PHP API.

py_client_cap-0.1.7.dist-info/RECORD

@@ -0,0 +1,13 @@
+py_client_cap/__init__.py,sha256=RV6Jph8QIp0NHnxj8ykvzZHWs5rG8r1-Y_MfxWYtUkc,160
+py_client_cap/crud_php_api.py,sha256=sNy3uUTuI0IKNw-fhTr5XSpoS6tfcn1CwJ-gqxuOyL4,6661
+py_client_cap/crud_php_table.py,sha256=UERZvDs_tHarWKmRg-qDaiPsddOBNNo3CRShKg4Ub9g,3751
+py_client_cap/manager.py,sha256=FxEQh9tc6N4jFNgOLG0CKALpDd3_B3HyTrPHcCKGtr8,1091
+py_client_cap/models/__init__.py,sha256=aVKe51v5ve_nfsoA1iqGh02pIvqCZ-LJ16paZenHwDY,141
+py_client_cap/models/apiresponse.py,sha256=hsKKa8Y1BNRIPuI8I7ZCgCgzSGM1cvutIa-YlNrFvus,467
+py_client_cap/models/column.py,sha256=Bj1NeWOp0DEojIdD6O4P49--nJX9RgBJXZXKrSckxcQ,160
+py_client_cap/models/item.py,sha256=BAoBlf2RVX1N-fWMd6G1MCvzy34eSXs6uERHKrEvoyY,291
+py_client_cap/models/table.py,sha256=hLUpzcIh3LPUJZ8jkDGaZgDnLfjnDiieJzl1dJQzj2E,1248
+py_client_cap-0.1.7.dist-info/METADATA,sha256=St2xdlEiO6pTkuFYtwjbjOYCb6TQjrDa3pC65-gU5r4,7198
+py_client_cap-0.1.7.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+py_client_cap-0.1.7.dist-info/top_level.txt,sha256=-0C4bPZLCM4dW6HC_6VrL2WSWXjjeakObCd3sB-_fgI,14
+py_client_cap-0.1.7.dist-info/RECORD,,

py_client_cap-0.1.7.dist-info/WHEEL

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

py_client_cap-0.1.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+py_client_cap