IoSL/service-aware-frontend
3
0
Fork 0
generated from Luis/nextjs-python-web-template
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename producer to service and consumer to client #41

Merged
merge-bot merged 8 commits from Qubasa-main into main 2024-01-07 14:24:17 +00:00
Conversation 0 Commits 8 Files Changed 88 +8735 -1198
88 changed files with 8735 additions and 1198 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
formatter.nix
View File

@@ -25,6 +25,7 @@
"pkgs/clan-cli".extraPythonPackages = self'.packages.clan-cli.pytestDependencies;
};
treefmt.settings.formatter.nix = {
command = "sh";
options = [
@@ -51,6 +52,7 @@
"--" # this argument is ignored by bash
];
includes = [ "*.py" ];
excludes = [ "**/tests/openapi_client/**" ];
};
};
}

1
pkgs/clan-cli/bin/gen-openapi Normal file → Executable file
View File

@@ -1,4 +1,5 @@
#!/usr/bin/env python
import argparse
import json
import sys

91
pkgs/clan-cli/bin/gen-python-client Executable file
View File

@@ -0,0 +1,91 @@
#!/usr/bin/env python
import argparse
import json
import sys
from pathlib import Path
import tempfile
from uvicorn.importer import import_from_string
import subprocess
import shutil
import os
import re
def replace_line_in_file(file_path: Path, pattern: str, replacement: str) -> None:
with open(file_path, 'r') as file:
content = file.read()
updated_content = re.sub(pattern, replacement, content)
with open(file_path, 'w') as file:
file.write(updated_content)
def replace_in_directory(*, directory_path: Path, pattern: str, replacement: str) -> None:
for root, dirs, files in os.walk(directory_path):
for file in files:
file_path = Path(os.path.join(root, file))
replace_line_in_file(file_path, pattern, replacement)
def main() -> None:
parser = argparse.ArgumentParser(prog="gen-openapi")
parser.add_argument(
"--app", help='App import string. Eg. "clan_cli.webui.app:app"', default="clan_cli.webui.app:app"
)
parser.add_argument("--app-dir", help="Directory containing the app", default=".")
parser.add_argument(
"--out", help="Output file ending in .json", default="tests", type=Path
)
args = parser.parse_args()
if args.app_dir is not None:
print(f"adding {args.app_dir} to sys.path")
sys.path.insert(0, args.app_dir)
print(f"importing app from {args.app}")
app = import_from_string(args.app)
openapi = app.openapi()
version = openapi.get("openapi", "unknown version")
print(f"writing openapi spec v{version}")
with tempfile.TemporaryDirectory() as tmpdirname:
tmp_dir = Path(tmpdirname)
openapi_p = tmp_dir / "openapi.json"
openapi_p.write_text(json.dumps(openapi, indent=2))
gen_code = tmp_dir / "gen_code"
print(f"generating python client to {args.out}")
if not args.out.is_dir():
raise Exception(f"{args.out} is not a directory")
args.out.mkdir(parents=True, exist_ok=True)
cmd = [
"openapi-generator-cli",
"generate",
"-g",
"python",
"-o",
f"{gen_code}",
"-i",
f"{openapi_p}",
"--additional-properties=generateSourceCodeOnly=true"
]
subprocess.run(cmd, check=True, text=True)
src_client: Path = gen_code / "openapi_client"
pattern = r"from typing import Any, List, Optional"
replacement = "from typing import Any, List, Optional, Dict"
replace_in_directory(directory_path=src_client, pattern=pattern, replacement=replacement)
dst_client: Path = args.out / "openapi_client"
shutil.rmtree(dst_client, ignore_errors=True)
shutil.copytree(src_client, dst_client)
if __name__ == "__main__":
main()

20
pkgs/clan-cli/clan_cli/webui/app.py
View File

@@ -13,13 +13,23 @@ from ..errors import ClanError
from . import sql_models
from .assets import asset_path
from .error_handlers import clan_error_handler, sql_error_handler
from .routers import health, root, socket_manager2, sql_connect # sql router hinzufügen
from .routers import endpoints, health, root, socket_manager2 # sql router hinzufügen
from .sql_db import engine
from .tags import tags_metadata
origins = [
"http://localhost:3000",
cors_url = [
"http://localhost",
"http://127.0.0.1",
"http://0.0.0.0",
"http://[::]",
]
cors_ports = [2979, 3000]
cors_whitelist = []
for u in cors_url:
for p in cors_ports:
cors_whitelist.append(f"{u}:{p}")
# Logging setup
log = logging.getLogger(__name__)
@@ -42,7 +52,7 @@ def setup_app() -> FastAPI:
app = FastAPI(lifespan=lifespan, swagger_ui_parameters={"tryItOutEnabled": True})
app.add_middleware(
CORSMiddleware,
allow_origins=origins,
allow_origins=cors_whitelist,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
@@ -50,7 +60,7 @@ def setup_app() -> FastAPI:
app.include_router(health.router)
# sql methodes
app.include_router(sql_connect.router)
app.include_router(endpoints.router)
app.include_router(socket_manager2.router)

238
pkgs/clan-cli/clan_cli/webui/routers/endpoints.py Normal file
View File

@@ -0,0 +1,238 @@
import logging
import time
from datetime import datetime
from typing import List, Optional
import httpx
from fastapi import APIRouter, BackgroundTasks, Depends
from sqlalchemy.orm import Session
from ...errors import ClanError
from .. import sql_crud, sql_db, sql_models
from ..schemas import (
Entity,
EntityCreate,
Resolution,
Service,
ServiceCreate,
ServicesByName,
)
from ..tags import Tags
router = APIRouter()
log = logging.getLogger(__name__)
#########################
# #
# Service #
# #
#########################
@router.post("/api/v1/service", response_model=Service, tags=[Tags.services])
async def create_service(
service: ServiceCreate, db: Session = Depends(sql_db.get_db)
) -> Service:
# todo checken ob schon da ...
return sql_crud.create_service(db=db, service=service)
@router.get("/api/v1/services", response_model=List[Service], tags=[Tags.services])
async def get_all_services(
skip: int = 0, limit: int = 100, db: Session = Depends(sql_db.get_db)
) -> List[sql_models.Service]:
services = sql_crud.get_services(db, skip=skip, limit=limit)
return services
@router.get(
"/api/v1/{entity_did}/service", response_model=List[Service], tags=[Tags.services]
)
async def get_service_by_did(
entity_did: str = "did:sov:test:1234",
skip: int = 0,
limit: int = 100,
db: Session = Depends(sql_db.get_db),
) -> List[sql_models.Service]:
service = sql_crud.get_services_by_entity_did(db, entity_did=entity_did)
return service
@router.get(
"/api/v1/services_by_entity_name",
response_model=ServicesByName,
tags=[Tags.services],
)
async def get_services_by_name(
entity_name: str,
skip: int = 0,
limit: int = 100,
db: Session = Depends(sql_db.get_db),
) -> ServicesByName:
entity = sql_crud.get_entity_by_name(db, name=entity_name)
if entity is None:
raise ClanError(f"Entity with name '{entity_name}' not found")
services = sql_crud.get_services_by_entity_did(db, entity_did=str(entity.did))
return ServicesByName(entity=entity, services=services) # type: ignore
@router.delete("/api/v1/{entity_did}/service", tags=[Tags.services])
async def delete_service(
entity_did: str = "did:sov:test:1234",
db: Session = Depends(sql_db.get_db),
) -> dict[str, str]:
sql_crud.delete_service_by_entity_did(db, entity_did)
return {"message": "service deleted"}
#########################
# #
# REPOSITORY #
# #
#########################
@router.get(
"/api/v1/repositories",
response_model=List[Service],
tags=[Tags.repositories],
)
async def get_all_repositories(
skip: int = 0, limit: int = 100, db: Session = Depends(sql_db.get_db)
) -> List[sql_models.Service]:
repositories = sql_crud.get_services(db, skip=skip, limit=limit)
return repositories
#########################
# #
# Entity #
# #
#########################
@router.post("/api/v1/entity", response_model=Entity, tags=[Tags.entities])
async def create_entity(
entity: EntityCreate, db: Session = Depends(sql_db.get_db)
) -> EntityCreate:
return sql_crud.create_entity(db, entity)
@router.get(
"/api/v1/entity_by_name", response_model=Optional[Entity], tags=[Tags.entities]
)
async def get_entity_by_name(
entity_name: str, db: Session = Depends(sql_db.get_db)
) -> Optional[sql_models.Entity]:
entity = sql_crud.get_entity_by_name(db, name=entity_name)
return entity
@router.get("/api/v1/entities", response_model=List[Entity], tags=[Tags.entities])
async def get_all_entities(
skip: int = 0, limit: int = 100, db: Session = Depends(sql_db.get_db)
) -> List[sql_models.Entity]:
entities = sql_crud.get_entities(db, skip=skip, limit=limit)
return entities
@router.get(
"/api/v1/{entity_did}/entity", response_model=Optional[Entity], tags=[Tags.entities]
)
async def get_entity_by_did(
entity_did: str = "did:sov:test:1234",
db: Session = Depends(sql_db.get_db),
) -> Optional[sql_models.Entity]:
entity = sql_crud.get_entity_by_did(db, did=entity_did)
return entity
@router.get(
"/api/v1/attached_entities",
response_model=List[Entity],
tags=[Tags.entities],
)
async def get_attached_entities(
skip: int = 0, limit: int = 100, db: Session = Depends(sql_db.get_db)
) -> List[sql_models.Entity]:
entities = sql_crud.get_attached_entities(db, skip=skip, limit=limit)
return entities
@router.post("/api/v1/{entity_did}/detach", response_model=Entity, tags=[Tags.entities])
async def detach_entity(
background_tasks: BackgroundTasks,
entity_did: str = "did:sov:test:1234",
skip: int = 0,
limit: int = 100,
db: Session = Depends(sql_db.get_db),
) -> sql_models.Entity:
entity = sql_crud.set_attached_by_entity_did(db, entity_did, False)
return entity
@router.post("/api/v1/{entity_did}/attach", tags=[Tags.entities])
async def attach_entity(
background_tasks: BackgroundTasks,
entity_did: str = "did:sov:test:1234",
skip: int = 0,
limit: int = 100,
db: Session = Depends(sql_db.get_db),
) -> dict[str, str]:
if sql_crud.get_entity_by_did(db, entity_did) is None:
raise ClanError(f"Entity with did '{entity_did}' not found")
background_tasks.add_task(attach_entity_loc, db, entity_did)
return {"message": "Attaching in the background"}
def attach_entity_loc(db: Session, entity_did: str) -> None:
db_entity = sql_crud.set_attached_by_entity_did(db, entity_did, True)
try:
while db_entity.attached:
# query status endpoint
# https://www.python-httpx.org/
response = httpx.get(f"http://{db_entity.ip}", timeout=2)
print(response)
# test with:
# while true ; do printf 'HTTP/1.1 200 OK\r\n\r\ncool, thanks' | nc -l -N localhost 5555 ; done
# client test (apt install python3-httpx):
# httpx http://localhost:5555
# except not reached set false
time.sleep(1)
except Exception:
log.warning(f"Entity {entity_did} not reachable. Setting attached to false")
db_entity = sql_crud.set_attached_by_entity_did(db, entity_did, False)
@router.delete("/api/v1/{entity_did}/entity", tags=[Tags.entities])
async def delete_entity(
entity_did: str = "did:sov:test:1234",
db: Session = Depends(sql_db.get_db),
) -> dict[str, str]:
sql_crud.delete_entity_by_did_recursive(db, did=entity_did)
return {"message": "Entity deleted and all relations to that entity"}
#########################
# #
# Resolution #
# #
#########################
@router.get(
"/api/v1/resolutions", response_model=List[Resolution], tags=[Tags.resolutions]
)
async def get_all_resolutions(
skip: int = 0, limit: int = 100, db: Session = Depends(sql_db.get_db)
) -> List[Resolution]:
# TODO: Get resolutions from DLG entity
return [
Resolution(
requester_name="C1",
requester_did="did:sov:test:1122",
resolved_did="did:sov:test:1234",
other={"test": "test"},
timestamp=datetime.now(),
id=1,
)
]

312
pkgs/clan-cli/clan_cli/webui/routers/sql_connect.py
View File

@@ -1,312 +0,0 @@
import logging
import time
from typing import List, Optional
import httpx
from fastapi import APIRouter, BackgroundTasks, Depends
from sqlalchemy.orm import Session
from ...errors import ClanError
from .. import sql_crud, sql_db, sql_models
from ..schemas import (
Consumer,
ConsumerCreate,
Entity,
EntityCreate,
Producer,
ProducerCreate,
Repository,
RepositoryCreate,
Resolution,
ResolutionCreate,
)
from ..tags import Tags
router = APIRouter()
log = logging.getLogger(__name__)
#########################
# #
# Producer #
# #
#########################
@router.post("/api/v1/create_producer", response_model=Producer, tags=[Tags.producers])
def create_producer(
producer: ProducerCreate, db: Session = Depends(sql_db.get_db)
) -> Producer:
# todo checken ob schon da ...
return sql_crud.create_producer(db=db, producer=producer)
@router.get(
"/api/v1/get_producers", response_model=List[Producer], tags=[Tags.producers]
)
def get_producers(
skip: int = 0, limit: int = 100, db: Session = Depends(sql_db.get_db)
) -> List[sql_models.Producer]:
producers = sql_crud.get_producers(db, skip=skip, limit=limit)
return producers
@router.get(
"/api/v1/get_producer", response_model=List[Producer], tags=[Tags.producers]
)
def get_producer(
entity_did: str = "did:sov:test:1234",
skip: int = 0,
limit: int = 100,
db: Session = Depends(sql_db.get_db),
) -> List[sql_models.Producer]:
producer = sql_crud.get_producers_by_entity_did(db, entity_did=entity_did)
return producer
@router.delete("/api/v1/delete_producer", tags=[Tags.producers])
def delete_producer(
entity_did: str = "did:sov:test:1234",
db: Session = Depends(sql_db.get_db),
) -> dict[str, str]:
sql_crud.delete_producer_by_entity_did(db, entity_did)
return {"message": "Producer deleted"}
#########################
# #
# Consumer #
# #
#########################
@router.post("/api/v1/create_consumer", response_model=Consumer, tags=[Tags.consumers])
def create_consumer(
consumer: ConsumerCreate, db: Session = Depends(sql_db.get_db)
) -> Consumer:
# todo checken ob schon da ...
return sql_crud.create_consumer(db=db, consumer=consumer)
@router.get(
"/api/v1/get_consumers", response_model=List[Consumer], tags=[Tags.consumers]
)
def get_consumers(
skip: int = 0, limit: int = 100, db: Session = Depends(sql_db.get_db)
) -> List[sql_models.Consumer]:
consumers = sql_crud.get_consumers(db, skip=skip, limit=limit)
return consumers
@router.get(
"/api/v1/get_consumer", response_model=List[Consumer], tags=[Tags.consumers]
)
def get_consumer(
entity_did: str = "did:sov:test:1234",
skip: int = 0,
limit: int = 100,
db: Session = Depends(sql_db.get_db),
) -> List[sql_models.Consumer]:
consumer = sql_crud.get_consumers_by_entity_did(db, entity_did=entity_did)
return consumer
@router.delete("/api/v1/delete_consumer", tags=[Tags.consumers])
def delete_consumer(
entity_did: str = "did:sov:test:1234",
db: Session = Depends(sql_db.get_db),
) -> dict[str, str]:
sql_crud.delete_consumer_by_entity_did(db, entity_did)
return {"message": "Consumer deleted"}
#########################
# #
# REPOSITORY #
# #
#########################
@router.post(
"/api/v1/create_repository", response_model=Repository, tags=[Tags.repositories]
)
def create_repository(
repository: RepositoryCreate, db: Session = Depends(sql_db.get_db)
) -> sql_models.Repository:
# todo checken ob schon da ...
return sql_crud.create_repository(db=db, repository=repository)
@router.get(
"/api/v1/get_repositories",
response_model=List[Repository],
tags=[Tags.repositories],
)
def get_repositories(
skip: int = 0, limit: int = 100, db: Session = Depends(sql_db.get_db)
) -> List[sql_models.Repository]:
repositories = sql_crud.get_repositories(db, skip=skip, limit=limit)
return repositories
@router.get(
"/api/v1/get_repository", response_model=List[Repository], tags=[Tags.repositories]
)
def get_repository(
entity_did: str = "did:sov:test:1234",
skip: int = 0,
limit: int = 100,
db: Session = Depends(sql_db.get_db),
) -> List[sql_models.Repository]:
repository = sql_crud.get_repository_by_entity_did(db, did=entity_did)
return repository
@router.delete("/api/v1/delete_repository", tags=[Tags.repositories])
def delete_repository(
entity_did: str = "did:sov:test:1234",
db: Session = Depends(sql_db.get_db),
) -> dict[str, str]:
sql_crud.delete_repository_by_entity_did(db, did=entity_did)
return {"message": "Repository deleted"}
#########################
# #
# Entity #
# #
#########################
@router.post("/api/v1/create_entity", response_model=Entity, tags=[Tags.entities])
def create_entity(
entity: EntityCreate, db: Session = Depends(sql_db.get_db)
) -> EntityCreate:
return sql_crud.create_entity(db, entity)
@router.get("/api/v1/get_entities", response_model=List[Entity], tags=[Tags.entities])
def get_entities(
skip: int = 0, limit: int = 100, db: Session = Depends(sql_db.get_db)
) -> List[sql_models.Entity]:
entities = sql_crud.get_entities(db, skip=skip, limit=limit)
return entities
@router.get("/api/v1/get_entity", response_model=Optional[Entity], tags=[Tags.entities])
def get_entity(
entity_did: str = "did:sov:test:1234",
db: Session = Depends(sql_db.get_db),
) -> Optional[sql_models.Entity]:
entity = sql_crud.get_entity_by_did(db, did=entity_did)
return entity
@router.get(
"/api/v1/get_attached_entities",
response_model=List[Entity],
tags=[Tags.entities],
)
def get_attached_entities(
skip: int = 0, limit: int = 100, db: Session = Depends(sql_db.get_db)
) -> List[sql_models.Entity]:
entities = sql_crud.get_attached_entities(db, skip=skip, limit=limit)
return entities
@router.post("/api/v1/detach", response_model=Entity, tags=[Tags.entities])
async def detach(
background_tasks: BackgroundTasks,
entity_did: str = "did:sov:test:1234",
skip: int = 0,
limit: int = 100,
db: Session = Depends(sql_db.get_db),
) -> sql_models.Entity:
entity = sql_crud.set_attached_by_entity_did(db, entity_did, False)
return entity
@router.post("/api/v1/attach", tags=[Tags.entities])
async def attach(
background_tasks: BackgroundTasks,
entity_did: str = "did:sov:test:1234",
skip: int = 0,
limit: int = 100,
db: Session = Depends(sql_db.get_db),
) -> dict[str, str]:
if sql_crud.get_entity_by_did(db, entity_did) is None:
raise ClanError(f"Entity with did '{entity_did}' not found")
background_tasks.add_task(attach_entity, db, entity_did)
return {"message": "Attaching in the background"}
def attach_entity(db: Session, entity_did: str) -> None:
db_entity = sql_crud.set_attached_by_entity_did(db, entity_did, True)
try:
while db_entity.attached:
# query status endpoint
# https://www.python-httpx.org/
response = httpx.get(f"http://{db_entity.ip}", timeout=2)
print(response)
# test with:
# while true ; do printf 'HTTP/1.1 200 OK\r\n\r\ncool, thanks' | nc -l -N localhost 5555 ; done
# client test (apt install python3-httpx):
# httpx http://localhost:5555
# except not reached set false
time.sleep(1)
except Exception:
log.warning(f"Entity {entity_did} not reachable. Setting attached to false")
db_entity = sql_crud.set_attached_by_entity_did(db, entity_did, False)
@router.delete("/api/v1/delete_entity_recursive", tags=[Tags.entities])
def delete_entity(
entity_did: str = "did:sov:test:1234",
db: Session = Depends(sql_db.get_db),
) -> dict[str, str]:
sql_crud.delete_entity_by_did_recursive(db, did=entity_did)
return {"message": "Entity deleted and all relations to that entity"}
#########################
# #
# Resolution #
# #
#########################
@router.post(
"/api/v1/create_resolution", response_model=Resolution, tags=[Tags.resolutions]
)
def create_resolution(
resolution: ResolutionCreate,
db: Session = Depends(sql_db.get_db),
) -> sql_models.Resolution:
return sql_crud.create_resolution(db, resolution)
@router.get(
"/api/v1/get_resolutions", response_model=List[Resolution], tags=[Tags.resolutions]
)
def get_resolutions(
skip: int = 0, limit: int = 100, db: Session = Depends(sql_db.get_db)
) -> List[sql_models.Resolution]:
resolutions = sql_crud.get_resolutions(db, skip=skip, limit=limit)
return resolutions
@router.get(
"/api/v1/get_resolution", response_model=List[Resolution], tags=[Tags.resolutions]
)
def get_resolution(
requester_did: str = "did:sov:test:1122",
skip: int = 0,
limit: int = 100,
db: Session = Depends(sql_db.get_db),
) -> List[sql_models.Resolution]:
resolution = sql_crud.get_resolution_by_requester_did(
db, requester_did=requester_did
)
return resolution
@router.delete("/api/v1/delete_resolution", tags=[Tags.resolutions])
def delete_resolution(
requester_did: str = "did:sov:test:1122",
db: Session = Depends(sql_db.get_db),
) -> dict[str, str]:
sql_crud.delete_resolution_by_requester_did(db, requester_did=requester_did)
return {"message": "Resolution deleted"}

134
pkgs/clan-cli/clan_cli/webui/schemas.py
View File

@@ -2,7 +2,7 @@ from datetime import datetime
from enum import Enum
from typing import List
from pydantic import BaseModel
from pydantic import BaseModel, Field
class Status(Enum):
@@ -16,86 +16,23 @@ class Machine(BaseModel):
status: Status
#########################
# #
# Producer #
# #
#########################
class ProducerBase(BaseModel):
uuid: str = "8e285c0c-4e40-430a-a477-26b3b81e30df"
service_name: str = "Carlo's Printing"
service_type: str = "3D Printing"
endpoint_url: str = "http://127.0.0.1:8000"
status: str = "unknown"
other: dict = {"action": ["register", "deregister", "delete", "create"]}
class ProducerCreate(ProducerBase):
entity_did: str = "did:sov:test:1234"
class Producer(ProducerCreate):
class Config:
orm_mode = True
#########################
# #
# Consumer #
# #
#########################
class ConsumerBase(BaseModel):
entity_did: str = "did:sov:test:1234"
producer_uuid: str = "8e285c0c-4e40-430a-a477-26b3b81e30df"
other: dict = {"test": "test"}
class ConsumerCreate(ConsumerBase):
pass
class Consumer(ConsumerCreate):
id: int
class Config:
orm_mode = True
#########################
# #
# REPOSITORY #
# #
#########################
class RepositoryBase(ProducerBase):
pass
class RepositoryCreate(RepositoryBase):
entity_did: str = "did:sov:test:1234"
class Repository(RepositoryCreate):
time_created: datetime
class Config:
orm_mode = True
#########################
# #
# Entity #
# #
#########################
class EntityBase(BaseModel):
did: str = "did:sov:test:1234"
name: str = "C1"
ip: str = "127.0.0.1"
attached: bool = False
visible: bool = True
other: dict = {
"network": "Carlo's Home Network",
did: str = Field(..., example="did:sov:test:1234")
name: str = Field(..., example="C1")
ip: str = Field(..., example="127.0.0.1")
visible: bool = Field(..., example=True)
other: dict = Field(
...,
example={
"network": "Carlos Home Network",
"roles": ["service repository", "service prosumer"],
}
},
)
class EntityCreate(EntityBase):
@@ -103,9 +40,42 @@ class EntityCreate(EntityBase):
class Entity(EntityCreate):
producers: List[Producer] = []
consumers: List[Consumer] = []
repository: List[Repository] = []
attached: bool = Field(...)
class Config:
orm_mode = True
#########################
# #
# Service #
# #
#########################
class ServiceBase(BaseModel):
uuid: str = Field(..., example="8e285c0c-4e40-430a-a477-26b3b81e30df")
service_name: str = Field(..., example="Carlos Printing")
service_type: str = Field(..., example="3D Printing")
endpoint_url: str = Field(..., example="http://127.0.0.1:8000")
status: str = Field(..., example="unknown")
other: dict = Field(
..., example={"action": ["register", "deregister", "delete", "create"]}
)
class ServiceCreate(ServiceBase):
entity_did: str = Field(..., example="did:sov:test:1234")
class Service(ServiceCreate):
entity: Entity
class Config:
orm_mode = True
class ServicesByName(BaseModel):
entity: Entity
services: List[Service]
class Config:
orm_mode = True
@@ -116,13 +86,11 @@ class Entity(EntityCreate):
# Resolution #
# #
#########################
class ResolutionBase(BaseModel):
requester_name: str = "C1"
requester_did: str = "did:sov:test:1122"
resolved_did: str = "did:sov:test:1234"
other: dict = {"test": "test"}
requester_name: str = Field(..., example="C1")
requester_did: str = Field(..., example="did:sov:test:1122")
resolved_did: str = Field(..., example="did:sov:test:1234")
other: dict = Field(..., example={"test": "test"})
class ResolutionCreate(ResolutionBase):

170
pkgs/clan-cli/clan_cli/webui/sql_crud.py
View File

@@ -8,143 +8,63 @@ from . import schemas, sql_models
#########################
# #
# Producer #
# service #
# #
#########################
def create_producer(
db: Session, producer: schemas.ProducerCreate
) -> sql_models.Producer:
db_producer = sql_models.Producer(**producer.dict())
db.add(db_producer)
def create_service(db: Session, service: schemas.ServiceCreate) -> sql_models.Service:
db_service = sql_models.Service(**service.dict())
db.add(db_service)
db.commit()
db.refresh(db_producer)
return db_producer
db.refresh(db_service)
return db_service
def get_producers(
def get_services(
db: Session, skip: int = 0, limit: int = 100
) -> List[sql_models.Producer]:
return db.query(sql_models.Producer).offset(skip).limit(limit).all()
) -> List[sql_models.Service]:
return db.query(sql_models.Service).offset(skip).limit(limit).all()
def get_producers_by_entity_did(
def get_services_by_entity_did(
db: Session, entity_did: str, skip: int = 0, limit: int = 100
) -> List[sql_models.Producer]:
) -> List[sql_models.Service]:
return (
db.query(sql_models.Producer)
.filter(sql_models.Producer.entity_did == entity_did)
db.query(sql_models.Service)
.filter(sql_models.Service.entity_did == entity_did)
.offset(skip)
.limit(limit)
.all()
)
def delete_producer_by_entity_did(db: Session, entity_did: str) -> None:
db.query(sql_models.Producer).filter(
sql_models.Producer.entity_did == entity_did
def delete_service_by_entity_did(db: Session, entity_did: str) -> None:
db.query(sql_models.Service).filter(
sql_models.Service.entity_did == entity_did
).delete()
db.commit()
#########################
# #
# Consumer #
# #
#########################
def create_consumer(
db: Session, consumer: schemas.ConsumerCreate
) -> sql_models.Consumer:
db_consumer = sql_models.Consumer(**consumer.dict())
db.add(db_consumer)
db.commit()
db.refresh(db_consumer)
return db_consumer
def get_consumers(
db: Session, skip: int = 0, limit: int = 100
) -> List[sql_models.Consumer]:
return db.query(sql_models.Consumer).offset(skip).limit(limit).all()
def get_consumers_by_entity_did(
def get_services_without_entity_id(
db: Session, entity_did: str, skip: int = 0, limit: int = 100
) -> List[sql_models.Consumer]:
) -> List[sql_models.Service]:
return (
db.query(sql_models.Consumer)
.filter(sql_models.Consumer.entity_did == entity_did)
db.query(sql_models.Service)
.filter(sql_models.Service.entity_did != entity_did)
.offset(skip)
.limit(limit)
.all()
)
def delete_consumer_by_entity_did(db: Session, entity_did: str) -> None:
db.query(sql_models.Consumer).filter(
sql_models.Consumer.entity_did == entity_did
).delete()
db.commit()
#########################
# #
# REPOSITORY #
# #
#########################
def create_repository(
db: Session, repository: schemas.RepositoryCreate
) -> sql_models.Repository:
db_repository = sql_models.Repository(**repository.dict())
db.add(db_repository)
db.commit()
db.refresh(db_repository)
return db_repository
def get_repositories(
db: Session, skip: int = 0, limit: int = 100
) -> List[sql_models.Repository]:
return db.query(sql_models.Repository).offset(skip).limit(limit).all()
def get_repository_by_uuid(db: Session, uuid: str) -> Optional[sql_models.Repository]:
return (
db.query(sql_models.Repository)
.filter(sql_models.Repository.uuid == uuid)
.first()
)
def get_repository_by_entity_did(
db: Session, did: str, skip: int = 0, limit: int = 100
) -> List[sql_models.Repository]:
return (
db.query(sql_models.Repository)
.filter(sql_models.Repository.entity_did == did)
.offset(skip)
.limit(limit)
.all()
)
def delete_repository_by_entity_did(db: Session, did: str) -> None:
db.query(sql_models.Repository).filter(
sql_models.Repository.entity_did == did
).delete()
db.commit()
#########################
# #
# Entity #
# #
#########################
def create_entity(db: Session, entity: schemas.EntityCreate) -> sql_models.Entity:
db_entity = sql_models.Entity(**entity.dict())
db_entity = sql_models.Entity(**entity.dict(), attached=False)
db.add(db_entity)
db.commit()
db.refresh(db_entity)
@@ -161,6 +81,10 @@ def get_entity_by_did(db: Session, did: str) -> Optional[sql_models.Entity]:
return db.query(sql_models.Entity).filter(sql_models.Entity.did == did).first()
def get_entity_by_name(db: Session, name: str) -> Optional[sql_models.Entity]:
return db.query(sql_models.Entity).filter(sql_models.Entity.name == name).first()
# get attached
def get_attached_entities(
db: Session, skip: int = 0, limit: int = 100
@@ -198,47 +122,5 @@ def delete_entity_by_did(db: Session, did: str) -> None:
def delete_entity_by_did_recursive(db: Session, did: str) -> None:
delete_producer_by_entity_did(db, did)
delete_consumer_by_entity_did(db, did)
delete_repository_by_entity_did(db, did)
delete_service_by_entity_did(db, did)
delete_entity_by_did(db, did)
#########################
# #
# Resolution #
# #
#########################
def create_resolution(
db: Session, resolution: schemas.ResolutionCreate
) -> sql_models.Resolution:
db_resolution = sql_models.Resolution(**resolution.dict())
db.add(db_resolution)
db.commit()
db.refresh(db_resolution)
return db_resolution
def get_resolutions(
db: Session, skip: int = 0, limit: int = 100
) -> List[sql_models.Resolution]:
return db.query(sql_models.Resolution).offset(skip).limit(limit).all()
def get_resolution_by_requester_did(
db: Session, requester_did: str, skip: int = 0, limit: int = 100
) -> List[sql_models.Resolution]:
return (
db.query(sql_models.Resolution)
.filter(sql_models.Resolution.requester_did == requester_did)
.offset(skip)
.limit(limit)
.all()
)
def delete_resolution_by_requester_did(db: Session, requester_did: str) -> None:
db.query(sql_models.Resolution).filter(
sql_models.Resolution.requester_did == requester_did
).delete()
db.commit()

69
pkgs/clan-cli/clan_cli/webui/sql_models.py
View File

@@ -2,15 +2,11 @@ from sqlalchemy import (
JSON,
Boolean,
Column,
DateTime,
ForeignKey,
Integer,
String,
Text,
UniqueConstraint,
)
from sqlalchemy.orm import relationship
from sqlalchemy.sql import func
from .sql_db import Base
@@ -23,7 +19,7 @@ class Entity(Base):
## Queryable body ##
did = Column(String, primary_key=True, index=True)
name = Column(String, index=True)
name = Column(String, index=True, unique=True)
ip = Column(String, index=True)
attached = Column(Boolean, index=True)
visible = Column(Boolean, index=True)
@@ -33,13 +29,10 @@ class Entity(Base):
other = Column(JSON)
## Relations ##
producers = relationship("Producer", back_populates="entity")
consumers = relationship("Consumer", back_populates="entity")
repository = relationship("Repository", back_populates="entity")
# TODO maby refactor to repositories
services = relationship("Service", back_populates="entity")
class ProducerAbstract(Base):
class ServiceAbstract(Base):
__abstract__ = True
# Queryable body
@@ -54,58 +47,10 @@ class ProducerAbstract(Base):
other = Column(JSON)
class Producer(ProducerAbstract):
__tablename__ = "producers"
# Usage is the consumers column
class Service(ServiceAbstract):
__tablename__ = "services"
## Relations ##
# One entity can have many producers
entity = relationship("Entity", back_populates="producers")
# One entity can have many services
entity = relationship("Entity", back_populates="services")
entity_did = Column(String, ForeignKey("entities.did"))
# One producer has many consumers
consumers = relationship("Consumer", back_populates="producer")
class Consumer(Base):
__tablename__ = "consumers"
## Queryable body ##
id = Column(Integer, primary_key=True, index=True)
## Non queryable body ##
other = Column(JSON)
## Relations ##
# one entity can have many consumers
entity = relationship("Entity", back_populates="consumers")
entity_did = Column(String, ForeignKey("entities.did"))
# one consumer has one producer
producer = relationship("Producer", back_populates="consumers")
producer_uuid = Column(String, ForeignKey("producers.uuid"))
__table_args__ = (UniqueConstraint("producer_uuid", "entity_did"),)
class Repository(ProducerAbstract):
__tablename__ = "repositories"
time_created = Column(DateTime(timezone=True), server_default=func.now())
# one repository has one entity
entity = relationship("Entity", back_populates="repository")
entity_did = Column(Integer, ForeignKey("entities.did"))
# TODO: Ask how this works exactly
class Resolution(Base):
__tablename__ = "resolutions"
id = Column(Integer, primary_key=True)
requester_name = Column(String, index=True)
requester_did = Column(String, index=True)
resolved_did = Column(String, index=True)
other = Column(JSON)
timestamp = Column(DateTime(timezone=True), server_default=func.now())

12
pkgs/clan-cli/clan_cli/webui/tags.py
View File

@@ -3,8 +3,8 @@ from typing import Any, Dict, List
class Tags(Enum):
producers = "producers"
consumers = "consumers"
services = "services"
clients = "clients"
entities = "entities"
repositories = "repositories"
resolutions = "resolution"
@@ -15,12 +15,12 @@ class Tags(Enum):
tags_metadata: List[Dict[str, Any]] = [
{
"name": str(Tags.producers),
"description": "Operations on a producer.",
"name": str(Tags.services),
"description": "Operations on a service.",
},
{
"name": str(Tags.consumers),
"description": "Operations on a consumer.",
"name": str(Tags.clients),
"description": "Operations on a client.",
},
{
"name": str(Tags.entities),

9
pkgs/clan-cli/default.nix
View File

@@ -36,8 +36,10 @@
, mypy
, sqlalchemy
, websockets
, deal
, broadcaster
, aenum
, dateutil
, urllib3
}:
let
@@ -48,7 +50,6 @@ let
sqlalchemy
websockets
broadcaster
deal
];
pytestDependencies = runtimeDependencies ++ dependencies ++ [
@@ -63,6 +64,10 @@ let
git
gnupg
stdenv.cc
# openapi client deps
dateutil
aenum
urllib3
];
# Optional dependencies for clan cli, we re-expose them here to make sure they all build.

3
pkgs/clan-cli/emulate_entity.sh Executable file
View File

@@ -0,0 +1,3 @@
#!/usr/bin/env bash
while true ; do printf 'HTTP/1.1 200 OK\r\n\r\ncool, thanks' | nc -l -N 127.0.0.1 5555 ; done

1
pkgs/clan-cli/flake-module.nix
View File

@@ -8,7 +8,6 @@
clan-cli = pkgs.python3.pkgs.callPackage ./default.nix {
inherit (self'.packages) ui-assets;
inherit (inputs) nixpkgs;
inherit (inputs.nixpkgs-for-iosl.legacyPackages.${system}.python3Packages) deal;
inherit (inputs.nixpkgs-for-iosl.legacyPackages.${system}.python3Packages) broadcaster;
};
inherit (self'.packages.clan-cli) clan-openapi;

11
pkgs/clan-cli/pyproject.toml
View File

@@ -31,7 +31,14 @@ warn_redundant_casts = true
disallow_untyped_calls = true
disallow_untyped_defs = true
no_implicit_optional = true
exclude = "clan_cli.nixpkgs"
follow_imports = "normal"
exclude = [
"clan_cli.nixpkgs",
]
[[tool.mypy.overrides]]
module = "openapi_client.*"
ignore_errors = true
[[tool.mypy.overrides]]
module = "argcomplete.*"
@@ -60,9 +67,9 @@ ignore_missing_imports = true
[tool.ruff]
line-length = 88
select = [ "E", "F", "I", "N"]
ignore = [ "E501" ]
exclude = ["tests/openapi_client"]
[tool.black]
line-length = 88

3
pkgs/clan-cli/shell.nix
View File

@@ -1,4 +1,4 @@
{ nix-unit, clan-cli, ui-assets, system, mkShell, writeScriptBin, openssh, ruff, python3 }:
{ nix-unit, clan-cli, openapi-generator-cli, ui-assets, system, mkShell, writeScriptBin, openssh, ruff, python3 }:
let
checkScript = writeScriptBin "check" ''
nix build .#checks.${system}.{treefmt,clan-pytest} -L "$@"
@@ -19,6 +19,7 @@ mkShell {
openssh
ruff
clan-cli.checkPython
openapi-generator-cli
];
shellHook = ''

53
pkgs/clan-cli/tests/api.py
View File

@@ -1,9 +1,60 @@
import sys
import time
import urllib.request
from multiprocessing import Process
from typing import Generator
from urllib.error import URLError
import pytest
import uvicorn
from fastapi.testclient import TestClient
from openapi_client import ApiClient, Configuration
from clan_cli.webui.app import app
@pytest.fixture(scope="session")
def api() -> TestClient:
def test_client() -> TestClient:
return TestClient(app)
def get_health(*, url: str, max_retries: int = 20, delay: float = 0.2) -> str | None:
for attempt in range(max_retries):
try:
with urllib.request.urlopen(url) as response:
return response.read()
except URLError as e:
print(f"Attempt {attempt + 1} failed: {e.reason}", file=sys.stderr)
time.sleep(delay)
return None
# Pytest fixture to run the server in a separate process
@pytest.fixture(scope="session")
def server_url() -> Generator[str, None, None]:
port = 8000
host = "127.0.0.1"
proc = Process(
target=uvicorn.run,
args=(app,),
kwargs={"host": host, "port": port, "log_level": "info"},
daemon=True,
)
proc.start()
url = f"http://{host}:{port}"
res = get_health(url=url + "/health")
if res is None:
raise Exception(f"Couldn't reach {url} after starting server")
yield url
proc.terminate()
@pytest.fixture(scope="session")
def api_client(server_url: str) -> Generator[ApiClient, None, None]:
configuration = Configuration(host=server_url)
# Enter a context with an instance of the API client
with ApiClient(configuration) as api_client:
yield api_client

48
pkgs/clan-cli/tests/openapi_client/__init__.py Normal file
View File

@@ -0,0 +1,48 @@
# coding: utf-8
# flake8: noqa
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
__version__ = "1.0.0"
# import apis into sdk package
from openapi_client.api.default_api import DefaultApi
from openapi_client.api.entities_api import EntitiesApi
from openapi_client.api.repositories_api import RepositoriesApi
from openapi_client.api.resolution_api import ResolutionApi
from openapi_client.api.services_api import ServicesApi
# import ApiClient
from openapi_client.api_response import ApiResponse
from openapi_client.api_client import ApiClient
from openapi_client.configuration import Configuration
from openapi_client.exceptions import OpenApiException
from openapi_client.exceptions import ApiTypeError
from openapi_client.exceptions import ApiValueError
from openapi_client.exceptions import ApiKeyError
from openapi_client.exceptions import ApiAttributeError
from openapi_client.exceptions import ApiException
# import models into sdk package
from openapi_client.models.entity import Entity
from openapi_client.models.entity_create import EntityCreate
from openapi_client.models.http_validation_error import HTTPValidationError
from openapi_client.models.machine import Machine
from openapi_client.models.resolution import Resolution
from openapi_client.models.service import Service
from openapi_client.models.service_create import ServiceCreate
from openapi_client.models.services_by_name import ServicesByName
from openapi_client.models.status import Status
from openapi_client.models.validation_error import ValidationError
from openapi_client.models.validation_error_loc_inner import ValidationErrorLocInner

9
pkgs/clan-cli/tests/openapi_client/api/__init__.py Normal file
View File

@@ -0,0 +1,9 @@
# flake8: noqa
# import apis into api package
from openapi_client.api.default_api import DefaultApi
from openapi_client.api.entities_api import EntitiesApi
from openapi_client.api.repositories_api import RepositoriesApi
from openapi_client.api.resolution_api import ResolutionApi
from openapi_client.api.services_api import ServicesApi

437
pkgs/clan-cli/tests/openapi_client/api/default_api.py Normal file
View File

@@ -0,0 +1,437 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import re # noqa: F401
import io
import warnings
from pydantic import validate_arguments, ValidationError
from pydantic import StrictStr
from openapi_client.models.machine import Machine
from openapi_client.api_client import ApiClient
from openapi_client.api_response import ApiResponse
from openapi_client.exceptions import ( # noqa: F401
ApiTypeError,
ApiValueError
)
class DefaultApi:
"""NOTE: This class is auto generated by OpenAPI Generator
Ref: https://openapi-generator.tech
Do not edit the class manually.
"""
def __init__(self, api_client=None) -> None:
if api_client is None:
api_client = ApiClient.get_default()
self.api_client = api_client
@validate_arguments
def get(self, **kwargs) -> None: # noqa: E501
"""Get # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get(async_req=True)
>>> result = thread.get()
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _request_timeout: timeout setting for this request.
If one number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
if '_preload_content' in kwargs:
message = "Error! Please call the get_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
raise ValueError(message)
return self.get_with_http_info(**kwargs) # noqa: E501
@validate_arguments
def get_with_http_info(self, **kwargs) -> ApiResponse: # noqa: E501
"""Get # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the ApiResponse.data will
be set to none and raw_data will store the
HTTP response body without reading/decoding.
Default is True.
:type _preload_content: bool, optional
:param _return_http_data_only: response data instead of ApiResponse
object with status code, headers, etc
:type _return_http_data_only: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
_params = locals()
_all_params = [
]
_all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout',
'_request_auth',
'_content_type',
'_headers'
]
)
# validate the arguments
for _key, _val in _params['kwargs'].items():
if _key not in _all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get" % _key
)
_params[_key] = _val
del _params['kwargs']
_collection_formats = {}
# process the path parameters
_path_params = {}
# process the query parameters
_query_params = []
# process the header parameters
_header_params = dict(_params.get('_headers', {}))
# process the form parameters
_form_params = []
_files = {}
# process the body parameter
_body_params = None
# set the HTTP header `Accept`
_header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# authentication setting
_auth_settings = [] # noqa: E501
_response_types_map = {}
return self.api_client.call_api(
'/ws2_example', 'GET',
_path_params,
_query_params,
_header_params,
body=_body_params,
post_params=_form_params,
files=_files,
response_types_map=_response_types_map,
auth_settings=_auth_settings,
async_req=_params.get('async_req'),
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
_preload_content=_params.get('_preload_content', True),
_request_timeout=_params.get('_request_timeout'),
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))
@validate_arguments
def health(self, **kwargs) -> Machine: # noqa: E501
"""Health # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.health(async_req=True)
>>> result = thread.get()
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _request_timeout: timeout setting for this request.
If one number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: Machine
"""
kwargs['_return_http_data_only'] = True
if '_preload_content' in kwargs:
message = "Error! Please call the health_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
raise ValueError(message)
return self.health_with_http_info(**kwargs) # noqa: E501
@validate_arguments
def health_with_http_info(self, **kwargs) -> ApiResponse: # noqa: E501
"""Health # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.health_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the ApiResponse.data will
be set to none and raw_data will store the
HTTP response body without reading/decoding.
Default is True.
:type _preload_content: bool, optional
:param _return_http_data_only: response data instead of ApiResponse
object with status code, headers, etc
:type _return_http_data_only: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(Machine, status_code(int), headers(HTTPHeaderDict))
"""
_params = locals()
_all_params = [
]
_all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout',
'_request_auth',
'_content_type',
'_headers'
]
)
# validate the arguments
for _key, _val in _params['kwargs'].items():
if _key not in _all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method health" % _key
)
_params[_key] = _val
del _params['kwargs']
_collection_formats = {}
# process the path parameters
_path_params = {}
# process the query parameters
_query_params = []
# process the header parameters
_header_params = dict(_params.get('_headers', {}))
# process the form parameters
_form_params = []
_files = {}
# process the body parameter
_body_params = None
# set the HTTP header `Accept`
_header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# authentication setting
_auth_settings = [] # noqa: E501
_response_types_map = {
'200': "Machine",
}
return self.api_client.call_api(
'/health', 'GET',
_path_params,
_query_params,
_header_params,
body=_body_params,
post_params=_form_params,
files=_files,
response_types_map=_response_types_map,
auth_settings=_auth_settings,
async_req=_params.get('async_req'),
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
_preload_content=_params.get('_preload_content', True),
_request_timeout=_params.get('_request_timeout'),
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))
@validate_arguments
def root(self, path_name : StrictStr, **kwargs) -> None: # noqa: E501
"""Root # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.root(path_name, async_req=True)
>>> result = thread.get()
:param path_name: (required)
:type path_name: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _request_timeout: timeout setting for this request.
If one number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
if '_preload_content' in kwargs:
message = "Error! Please call the root_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
raise ValueError(message)
return self.root_with_http_info(path_name, **kwargs) # noqa: E501
@validate_arguments
def root_with_http_info(self, path_name : StrictStr, **kwargs) -> ApiResponse: # noqa: E501
"""Root # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.root_with_http_info(path_name, async_req=True)
>>> result = thread.get()
:param path_name: (required)
:type path_name: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the ApiResponse.data will
be set to none and raw_data will store the
HTTP response body without reading/decoding.
Default is True.
:type _preload_content: bool, optional
:param _return_http_data_only: response data instead of ApiResponse
object with status code, headers, etc
:type _return_http_data_only: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
_params = locals()
_all_params = [
'path_name'
]
_all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout',
'_request_auth',
'_content_type',
'_headers'
]
)
# validate the arguments
for _key, _val in _params['kwargs'].items():
if _key not in _all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method root" % _key
)
_params[_key] = _val
del _params['kwargs']
_collection_formats = {}
# process the path parameters
_path_params = {}
if _params['path_name']:
_path_params['path_name'] = _params['path_name']
# process the query parameters
_query_params = []
# process the header parameters
_header_params = dict(_params.get('_headers', {}))
# process the form parameters
_form_params = []
_files = {}
# process the body parameter
_body_params = None
# set the HTTP header `Accept`
_header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# authentication setting
_auth_settings = [] # noqa: E501
_response_types_map = {}
return self.api_client.call_api(
'/{path_name}', 'GET',
_path_params,
_query_params,
_header_params,
body=_body_params,
post_params=_form_params,
files=_files,
response_types_map=_response_types_map,
auth_settings=_auth_settings,
async_req=_params.get('async_req'),
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
_preload_content=_params.get('_preload_content', True),
_request_timeout=_params.get('_request_timeout'),
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))

1213
pkgs/clan-cli/tests/openapi_client/api/entities_api.py Normal file
View File

File diff suppressed because it is too large Load Diff

192
pkgs/clan-cli/tests/openapi_client/api/repositories_api.py Normal file
View File

@@ -0,0 +1,192 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import re # noqa: F401
import io
import warnings
from pydantic import validate_arguments, ValidationError
from pydantic import StrictInt
from typing import List, Optional
from openapi_client.models.service import Service
from openapi_client.api_client import ApiClient
from openapi_client.api_response import ApiResponse
from openapi_client.exceptions import ( # noqa: F401
ApiTypeError,
ApiValueError
)
class RepositoriesApi:
"""NOTE: This class is auto generated by OpenAPI Generator
Ref: https://openapi-generator.tech
Do not edit the class manually.
"""
def __init__(self, api_client=None) -> None:
if api_client is None:
api_client = ApiClient.get_default()
self.api_client = api_client
@validate_arguments
def get_all_repositories(self, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> List[Service]: # noqa: E501
"""Get All Repositories # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_all_repositories(skip, limit, async_req=True)
>>> result = thread.get()
:param skip:
:type skip: int
:param limit:
:type limit: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _request_timeout: timeout setting for this request.
If one number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: List[Service]
"""
kwargs['_return_http_data_only'] = True
if '_preload_content' in kwargs:
message = "Error! Please call the get_all_repositories_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
raise ValueError(message)
return self.get_all_repositories_with_http_info(skip, limit, **kwargs) # noqa: E501
@validate_arguments
def get_all_repositories_with_http_info(self, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> ApiResponse: # noqa: E501
"""Get All Repositories # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_all_repositories_with_http_info(skip, limit, async_req=True)
>>> result = thread.get()
:param skip:
:type skip: int
:param limit:
:type limit: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the ApiResponse.data will
be set to none and raw_data will store the
HTTP response body without reading/decoding.
Default is True.
:type _preload_content: bool, optional
:param _return_http_data_only: response data instead of ApiResponse
object with status code, headers, etc
:type _return_http_data_only: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(List[Service], status_code(int), headers(HTTPHeaderDict))
"""
_params = locals()
_all_params = [
'skip',
'limit'
]
_all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout',
'_request_auth',
'_content_type',
'_headers'
]
)
# validate the arguments
for _key, _val in _params['kwargs'].items():
if _key not in _all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_all_repositories" % _key
)
_params[_key] = _val
del _params['kwargs']
_collection_formats = {}
# process the path parameters
_path_params = {}
# process the query parameters
_query_params = []
if _params.get('skip') is not None: # noqa: E501
_query_params.append(('skip', _params['skip']))
if _params.get('limit') is not None: # noqa: E501
_query_params.append(('limit', _params['limit']))
# process the header parameters
_header_params = dict(_params.get('_headers', {}))
# process the form parameters
_form_params = []
_files = {}
# process the body parameter
_body_params = None
# set the HTTP header `Accept`
_header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# authentication setting
_auth_settings = [] # noqa: E501
_response_types_map = {
'200': "List[Service]",
'422': "HTTPValidationError",
}
return self.api_client.call_api(
'/api/v1/repositories', 'GET',
_path_params,
_query_params,
_header_params,
body=_body_params,
post_params=_form_params,
files=_files,
response_types_map=_response_types_map,
auth_settings=_auth_settings,
async_req=_params.get('async_req'),
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
_preload_content=_params.get('_preload_content', True),
_request_timeout=_params.get('_request_timeout'),
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))

192
pkgs/clan-cli/tests/openapi_client/api/resolution_api.py Normal file
View File

@@ -0,0 +1,192 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import re # noqa: F401
import io
import warnings
from pydantic import validate_arguments, ValidationError
from pydantic import StrictInt
from typing import List, Optional
from openapi_client.models.resolution import Resolution
from openapi_client.api_client import ApiClient
from openapi_client.api_response import ApiResponse
from openapi_client.exceptions import ( # noqa: F401
ApiTypeError,
ApiValueError
)
class ResolutionApi:
"""NOTE: This class is auto generated by OpenAPI Generator
Ref: https://openapi-generator.tech
Do not edit the class manually.
"""
def __init__(self, api_client=None) -> None:
if api_client is None:
api_client = ApiClient.get_default()
self.api_client = api_client
@validate_arguments
def get_all_resolutions(self, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> List[Resolution]: # noqa: E501
"""Get All Resolutions # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_all_resolutions(skip, limit, async_req=True)
>>> result = thread.get()
:param skip:
:type skip: int
:param limit:
:type limit: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _request_timeout: timeout setting for this request.
If one number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: List[Resolution]
"""
kwargs['_return_http_data_only'] = True
if '_preload_content' in kwargs:
message = "Error! Please call the get_all_resolutions_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
raise ValueError(message)
return self.get_all_resolutions_with_http_info(skip, limit, **kwargs) # noqa: E501
@validate_arguments
def get_all_resolutions_with_http_info(self, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> ApiResponse: # noqa: E501
"""Get All Resolutions # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_all_resolutions_with_http_info(skip, limit, async_req=True)
>>> result = thread.get()
:param skip:
:type skip: int
:param limit:
:type limit: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the ApiResponse.data will
be set to none and raw_data will store the
HTTP response body without reading/decoding.
Default is True.
:type _preload_content: bool, optional
:param _return_http_data_only: response data instead of ApiResponse
object with status code, headers, etc
:type _return_http_data_only: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(List[Resolution], status_code(int), headers(HTTPHeaderDict))
"""
_params = locals()
_all_params = [
'skip',
'limit'
]
_all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout',
'_request_auth',
'_content_type',
'_headers'
]
)
# validate the arguments
for _key, _val in _params['kwargs'].items():
if _key not in _all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_all_resolutions" % _key
)
_params[_key] = _val
del _params['kwargs']
_collection_formats = {}
# process the path parameters
_path_params = {}
# process the query parameters
_query_params = []
if _params.get('skip') is not None: # noqa: E501
_query_params.append(('skip', _params['skip']))
if _params.get('limit') is not None: # noqa: E501
_query_params.append(('limit', _params['limit']))
# process the header parameters
_header_params = dict(_params.get('_headers', {}))
# process the form parameters
_form_params = []
_files = {}
# process the body parameter
_body_params = None
# set the HTTP header `Accept`
_header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# authentication setting
_auth_settings = [] # noqa: E501
_response_types_map = {
'200': "List[Resolution]",
'422': "HTTPValidationError",
}
return self.api_client.call_api(
'/api/v1/resolutions', 'GET',
_path_params,
_query_params,
_header_params,
body=_body_params,
post_params=_form_params,
files=_files,
response_types_map=_response_types_map,
auth_settings=_auth_settings,
async_req=_params.get('async_req'),
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
_preload_content=_params.get('_preload_content', True),
_request_timeout=_params.get('_request_timeout'),
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))

789
pkgs/clan-cli/tests/openapi_client/api/services_api.py Normal file
View File

@@ -0,0 +1,789 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import re # noqa: F401
import io
import warnings
from pydantic import validate_arguments, ValidationError
from pydantic import StrictInt, StrictStr
from typing import Any, List, Optional, Dict
from openapi_client.models.service import Service
from openapi_client.models.service_create import ServiceCreate
from openapi_client.models.services_by_name import ServicesByName
from openapi_client.api_client import ApiClient
from openapi_client.api_response import ApiResponse
from openapi_client.exceptions import ( # noqa: F401
ApiTypeError,
ApiValueError
)
class ServicesApi:
"""NOTE: This class is auto generated by OpenAPI Generator
Ref: https://openapi-generator.tech
Do not edit the class manually.
"""
def __init__(self, api_client=None) -> None:
if api_client is None:
api_client = ApiClient.get_default()
self.api_client = api_client
@validate_arguments
def create_service(self, service_create : ServiceCreate, **kwargs) -> Service: # noqa: E501
"""Create Service # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_service(service_create, async_req=True)
>>> result = thread.get()
:param service_create: (required)
:type service_create: ServiceCreate
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _request_timeout: timeout setting for this request.
If one number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: Service
"""
kwargs['_return_http_data_only'] = True
if '_preload_content' in kwargs:
message = "Error! Please call the create_service_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
raise ValueError(message)
return self.create_service_with_http_info(service_create, **kwargs) # noqa: E501
@validate_arguments
def create_service_with_http_info(self, service_create : ServiceCreate, **kwargs) -> ApiResponse: # noqa: E501
"""Create Service # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_service_with_http_info(service_create, async_req=True)
>>> result = thread.get()
:param service_create: (required)
:type service_create: ServiceCreate
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the ApiResponse.data will
be set to none and raw_data will store the
HTTP response body without reading/decoding.
Default is True.
:type _preload_content: bool, optional
:param _return_http_data_only: response data instead of ApiResponse
object with status code, headers, etc
:type _return_http_data_only: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(Service, status_code(int), headers(HTTPHeaderDict))
"""
_params = locals()
_all_params = [
'service_create'
]
_all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout',
'_request_auth',
'_content_type',
'_headers'
]
)
# validate the arguments
for _key, _val in _params['kwargs'].items():
if _key not in _all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method create_service" % _key
)
_params[_key] = _val
del _params['kwargs']
_collection_formats = {}
# process the path parameters
_path_params = {}
# process the query parameters
_query_params = []
# process the header parameters
_header_params = dict(_params.get('_headers', {}))
# process the form parameters
_form_params = []
_files = {}
# process the body parameter
_body_params = None
if _params['service_create'] is not None:
_body_params = _params['service_create']
# set the HTTP header `Accept`
_header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# set the HTTP header `Content-Type`
_content_types_list = _params.get('_content_type',
self.api_client.select_header_content_type(
['application/json']))
if _content_types_list:
_header_params['Content-Type'] = _content_types_list
# authentication setting
_auth_settings = [] # noqa: E501
_response_types_map = {
'200': "Service",
'422': "HTTPValidationError",
}
return self.api_client.call_api(
'/api/v1/service', 'POST',
_path_params,
_query_params,
_header_params,
body=_body_params,
post_params=_form_params,
files=_files,
response_types_map=_response_types_map,
auth_settings=_auth_settings,
async_req=_params.get('async_req'),
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
_preload_content=_params.get('_preload_content', True),
_request_timeout=_params.get('_request_timeout'),
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))
@validate_arguments
def delete_service(self, entity_did : StrictStr, **kwargs) -> Dict[str, str]: # noqa: E501
"""Delete Service # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_service(entity_did, async_req=True)
>>> result = thread.get()
:param entity_did: (required)
:type entity_did: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _request_timeout: timeout setting for this request.
If one number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: Dict[str, str]
"""
kwargs['_return_http_data_only'] = True
if '_preload_content' in kwargs:
message = "Error! Please call the delete_service_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
raise ValueError(message)
return self.delete_service_with_http_info(entity_did, **kwargs) # noqa: E501
@validate_arguments
def delete_service_with_http_info(self, entity_did : StrictStr, **kwargs) -> ApiResponse: # noqa: E501
"""Delete Service # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_service_with_http_info(entity_did, async_req=True)
>>> result = thread.get()
:param entity_did: (required)
:type entity_did: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the ApiResponse.data will
be set to none and raw_data will store the
HTTP response body without reading/decoding.
Default is True.
:type _preload_content: bool, optional
:param _return_http_data_only: response data instead of ApiResponse
object with status code, headers, etc
:type _return_http_data_only: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(Dict[str, str], status_code(int), headers(HTTPHeaderDict))
"""
_params = locals()
_all_params = [
'entity_did'
]
_all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout',
'_request_auth',
'_content_type',
'_headers'
]
)
# validate the arguments
for _key, _val in _params['kwargs'].items():
if _key not in _all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method delete_service" % _key
)
_params[_key] = _val
del _params['kwargs']
_collection_formats = {}
# process the path parameters
_path_params = {}
if _params['entity_did']:
_path_params['entity_did'] = _params['entity_did']
# process the query parameters
_query_params = []
# process the header parameters
_header_params = dict(_params.get('_headers', {}))
# process the form parameters
_form_params = []
_files = {}
# process the body parameter
_body_params = None
# set the HTTP header `Accept`
_header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# authentication setting
_auth_settings = [] # noqa: E501
_response_types_map = {
'200': "Dict[str, str]",
'422': "HTTPValidationError",
}
return self.api_client.call_api(
'/api/v1/{entity_did}/service', 'DELETE',
_path_params,
_query_params,
_header_params,
body=_body_params,
post_params=_form_params,
files=_files,
response_types_map=_response_types_map,
auth_settings=_auth_settings,
async_req=_params.get('async_req'),
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
_preload_content=_params.get('_preload_content', True),
_request_timeout=_params.get('_request_timeout'),
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))
@validate_arguments
def get_all_services(self, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> List[Service]: # noqa: E501
"""Get All Services # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_all_services(skip, limit, async_req=True)
>>> result = thread.get()
:param skip:
:type skip: int
:param limit:
:type limit: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _request_timeout: timeout setting for this request.
If one number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: List[Service]
"""
kwargs['_return_http_data_only'] = True
if '_preload_content' in kwargs:
message = "Error! Please call the get_all_services_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
raise ValueError(message)
return self.get_all_services_with_http_info(skip, limit, **kwargs) # noqa: E501
@validate_arguments
def get_all_services_with_http_info(self, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> ApiResponse: # noqa: E501
"""Get All Services # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_all_services_with_http_info(skip, limit, async_req=True)
>>> result = thread.get()
:param skip:
:type skip: int
:param limit:
:type limit: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the ApiResponse.data will
be set to none and raw_data will store the
HTTP response body without reading/decoding.
Default is True.
:type _preload_content: bool, optional
:param _return_http_data_only: response data instead of ApiResponse
object with status code, headers, etc
:type _return_http_data_only: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(List[Service], status_code(int), headers(HTTPHeaderDict))
"""
_params = locals()
_all_params = [
'skip',
'limit'
]
_all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout',
'_request_auth',
'_content_type',
'_headers'
]
)
# validate the arguments
for _key, _val in _params['kwargs'].items():
if _key not in _all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_all_services" % _key
)
_params[_key] = _val
del _params['kwargs']
_collection_formats = {}
# process the path parameters
_path_params = {}
# process the query parameters
_query_params = []
if _params.get('skip') is not None: # noqa: E501
_query_params.append(('skip', _params['skip']))
if _params.get('limit') is not None: # noqa: E501
_query_params.append(('limit', _params['limit']))
# process the header parameters
_header_params = dict(_params.get('_headers', {}))
# process the form parameters
_form_params = []
_files = {}
# process the body parameter
_body_params = None
# set the HTTP header `Accept`
_header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# authentication setting
_auth_settings = [] # noqa: E501
_response_types_map = {
'200': "List[Service]",
'422': "HTTPValidationError",
}
return self.api_client.call_api(
'/api/v1/services', 'GET',
_path_params,
_query_params,
_header_params,
body=_body_params,
post_params=_form_params,
files=_files,
response_types_map=_response_types_map,
auth_settings=_auth_settings,
async_req=_params.get('async_req'),
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
_preload_content=_params.get('_preload_content', True),
_request_timeout=_params.get('_request_timeout'),
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))
@validate_arguments
def get_service_by_did(self, entity_did : StrictStr, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> List[Service]: # noqa: E501
"""Get Service By Did # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_service_by_did(entity_did, skip, limit, async_req=True)
>>> result = thread.get()
:param entity_did: (required)
:type entity_did: str
:param skip:
:type skip: int
:param limit:
:type limit: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _request_timeout: timeout setting for this request.
If one number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: List[Service]
"""
kwargs['_return_http_data_only'] = True
if '_preload_content' in kwargs:
message = "Error! Please call the get_service_by_did_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
raise ValueError(message)
return self.get_service_by_did_with_http_info(entity_did, skip, limit, **kwargs) # noqa: E501
@validate_arguments
def get_service_by_did_with_http_info(self, entity_did : StrictStr, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> ApiResponse: # noqa: E501
"""Get Service By Did # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_service_by_did_with_http_info(entity_did, skip, limit, async_req=True)
>>> result = thread.get()
:param entity_did: (required)
:type entity_did: str
:param skip:
:type skip: int
:param limit:
:type limit: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the ApiResponse.data will
be set to none and raw_data will store the
HTTP response body without reading/decoding.
Default is True.
:type _preload_content: bool, optional
:param _return_http_data_only: response data instead of ApiResponse
object with status code, headers, etc
:type _return_http_data_only: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(List[Service], status_code(int), headers(HTTPHeaderDict))
"""
_params = locals()
_all_params = [
'entity_did',
'skip',
'limit'
]
_all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout',
'_request_auth',
'_content_type',
'_headers'
]
)
# validate the arguments
for _key, _val in _params['kwargs'].items():
if _key not in _all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_service_by_did" % _key
)
_params[_key] = _val
del _params['kwargs']
_collection_formats = {}
# process the path parameters
_path_params = {}
if _params['entity_did']:
_path_params['entity_did'] = _params['entity_did']
# process the query parameters
_query_params = []
if _params.get('skip') is not None: # noqa: E501
_query_params.append(('skip', _params['skip']))
if _params.get('limit') is not None: # noqa: E501
_query_params.append(('limit', _params['limit']))
# process the header parameters
_header_params = dict(_params.get('_headers', {}))
# process the form parameters
_form_params = []
_files = {}
# process the body parameter
_body_params = None
# set the HTTP header `Accept`
_header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# authentication setting
_auth_settings = [] # noqa: E501
_response_types_map = {
'200': "List[Service]",
'422': "HTTPValidationError",
}
return self.api_client.call_api(
'/api/v1/{entity_did}/service', 'GET',
_path_params,
_query_params,
_header_params,
body=_body_params,
post_params=_form_params,
files=_files,
response_types_map=_response_types_map,
auth_settings=_auth_settings,
async_req=_params.get('async_req'),
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
_preload_content=_params.get('_preload_content', True),
_request_timeout=_params.get('_request_timeout'),
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))
@validate_arguments
def get_services_by_name(self, entity_name : StrictStr, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> ServicesByName: # noqa: E501
"""Get Services By Name # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_services_by_name(entity_name, skip, limit, async_req=True)
>>> result = thread.get()
:param entity_name: (required)
:type entity_name: str
:param skip:
:type skip: int
:param limit:
:type limit: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _request_timeout: timeout setting for this request.
If one number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: ServicesByName
"""
kwargs['_return_http_data_only'] = True
if '_preload_content' in kwargs:
message = "Error! Please call the get_services_by_name_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
raise ValueError(message)
return self.get_services_by_name_with_http_info(entity_name, skip, limit, **kwargs) # noqa: E501
@validate_arguments
def get_services_by_name_with_http_info(self, entity_name : StrictStr, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> ApiResponse: # noqa: E501
"""Get Services By Name # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_services_by_name_with_http_info(entity_name, skip, limit, async_req=True)
>>> result = thread.get()
:param entity_name: (required)
:type entity_name: str
:param skip:
:type skip: int
:param limit:
:type limit: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the ApiResponse.data will
be set to none and raw_data will store the
HTTP response body without reading/decoding.
Default is True.
:type _preload_content: bool, optional
:param _return_http_data_only: response data instead of ApiResponse
object with status code, headers, etc
:type _return_http_data_only: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(ServicesByName, status_code(int), headers(HTTPHeaderDict))
"""
_params = locals()
_all_params = [
'entity_name',
'skip',
'limit'
]
_all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout',
'_request_auth',
'_content_type',
'_headers'
]
)
# validate the arguments
for _key, _val in _params['kwargs'].items():
if _key not in _all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_services_by_name" % _key
)
_params[_key] = _val
del _params['kwargs']
_collection_formats = {}
# process the path parameters
_path_params = {}
# process the query parameters
_query_params = []
if _params.get('entity_name') is not None: # noqa: E501
_query_params.append(('entity_name', _params['entity_name']))
if _params.get('skip') is not None: # noqa: E501
_query_params.append(('skip', _params['skip']))
if _params.get('limit') is not None: # noqa: E501
_query_params.append(('limit', _params['limit']))
# process the header parameters
_header_params = dict(_params.get('_headers', {}))
# process the form parameters
_form_params = []
_files = {}
# process the body parameter
_body_params = None
# set the HTTP header `Accept`
_header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# authentication setting
_auth_settings = [] # noqa: E501
_response_types_map = {
'200': "ServicesByName",
'422': "HTTPValidationError",
}
return self.api_client.call_api(
'/api/v1/services_by_entity_name', 'GET',
_path_params,
_query_params,
_header_params,
body=_body_params,
post_params=_form_params,
files=_files,
response_types_map=_response_types_map,
auth_settings=_auth_settings,
async_req=_params.get('async_req'),
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
_preload_content=_params.get('_preload_content', True),
_request_timeout=_params.get('_request_timeout'),
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))

758
pkgs/clan-cli/tests/openapi_client/api_client.py Normal file
View File

@@ -0,0 +1,758 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import atexit
import datetime
from dateutil.parser import parse
import json
import mimetypes
from multiprocessing.pool import ThreadPool
import os
import re
import tempfile
from urllib.parse import quote
from openapi_client.configuration import Configuration
from openapi_client.api_response import ApiResponse
import openapi_client.models
from openapi_client import rest
from openapi_client.exceptions import ApiValueError, ApiException
class ApiClient:
"""Generic API client for OpenAPI client library builds.
OpenAPI generic API client. This client handles the client-
server communication, and is invariant across implementations. Specifics of
the methods and models for each application are generated from the OpenAPI
templates.
:param configuration: .Configuration object for this client
:param header_name: a header to pass when making calls to the API.
:param header_value: a header value to pass when making calls to
the API.
:param cookie: a cookie to include in the header when making calls
to the API
:param pool_threads: The number of threads to use for async requests
to the API. More threads means more concurrent API requests.
"""
PRIMITIVE_TYPES = (float, bool, bytes, str, int)
NATIVE_TYPES_MAPPING = {
'int': int,
'long': int, # TODO remove as only py3 is supported?
'float': float,
'str': str,
'bool': bool,
'date': datetime.date,
'datetime': datetime.datetime,
'object': object,
}
_pool = None
def __init__(self, configuration=None, header_name=None, header_value=None,
cookie=None, pool_threads=1) -> None:
# use default configuration if none is provided
if configuration is None:
configuration = Configuration.get_default()
self.configuration = configuration
self.pool_threads = pool_threads
self.rest_client = rest.RESTClientObject(configuration)
self.default_headers = {}
if header_name is not None:
self.default_headers[header_name] = header_value
self.cookie = cookie
# Set default User-Agent.
self.user_agent = 'OpenAPI-Generator/1.0.0/python'
self.client_side_validation = configuration.client_side_validation
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
self.close()
def close(self):
if self._pool:
self._pool.close()
self._pool.join()
self._pool = None
if hasattr(atexit, 'unregister'):
atexit.unregister(self.close)
@property
def pool(self):
"""Create thread pool on first request
avoids instantiating unused threadpool for blocking clients.
"""
if self._pool is None:
atexit.register(self.close)
self._pool = ThreadPool(self.pool_threads)
return self._pool
@property
def user_agent(self):
"""User agent for this API client"""
return self.default_headers['User-Agent']
@user_agent.setter
def user_agent(self, value):
self.default_headers['User-Agent'] = value
def set_default_header(self, header_name, header_value):
self.default_headers[header_name] = header_value
_default = None
@classmethod
def get_default(cls):
"""Return new instance of ApiClient.
This method returns newly created, based on default constructor,
object of ApiClient class or returns a copy of default
ApiClient.
:return: The ApiClient object.
"""
if cls._default is None:
cls._default = ApiClient()
return cls._default
@classmethod
def set_default(cls, default):
"""Set default instance of ApiClient.
It stores default ApiClient.
:param default: object of ApiClient.
"""
cls._default = default
def __call_api(
self, resource_path, method, path_params=None,
query_params=None, header_params=None, body=None, post_params=None,
files=None, response_types_map=None, auth_settings=None,
_return_http_data_only=None, collection_formats=None,
_preload_content=True, _request_timeout=None, _host=None,
_request_auth=None):
config = self.configuration
# header parameters
header_params = header_params or {}
header_params.update(self.default_headers)
if self.cookie:
header_params['Cookie'] = self.cookie
if header_params:
header_params = self.sanitize_for_serialization(header_params)
header_params = dict(self.parameters_to_tuples(header_params,
collection_formats))
# path parameters
if path_params:
path_params = self.sanitize_for_serialization(path_params)
path_params = self.parameters_to_tuples(path_params,
collection_formats)
for k, v in path_params:
# specified safe chars, encode everything
resource_path = resource_path.replace(
'{%s}' % k,
quote(str(v), safe=config.safe_chars_for_path_param)
)
# post parameters
if post_params or files:
post_params = post_params if post_params else []
post_params = self.sanitize_for_serialization(post_params)
post_params = self.parameters_to_tuples(post_params,
collection_formats)
post_params.extend(self.files_parameters(files))
# auth setting
self.update_params_for_auth(
header_params, query_params, auth_settings,
resource_path, method, body,
request_auth=_request_auth)
# body
if body:
body = self.sanitize_for_serialization(body)
# request url
if _host is None:
url = self.configuration.host + resource_path
else:
# use server/host defined in path or operation instead
url = _host + resource_path
# query parameters
if query_params:
query_params = self.sanitize_for_serialization(query_params)
url_query = self.parameters_to_url_query(query_params,
collection_formats)
url += "?" + url_query
try:
# perform request and return response
response_data = self.request(
method, url,
query_params=query_params,
headers=header_params,
post_params=post_params, body=body,
_preload_content=_preload_content,
_request_timeout=_request_timeout)
except ApiException as e:
if e.body:
e.body = e.body.decode('utf-8')
raise e
self.last_response = response_data
return_data = None # assuming derialization is not needed
# data needs deserialization or returns HTTP data (deserialized) only
if _preload_content or _return_http_data_only:
response_type = response_types_map.get(str(response_data.status), None)
if not response_type and isinstance(response_data.status, int) and 100 <= response_data.status <= 599:
# if not found, look for '1XX', '2XX', etc.
response_type = response_types_map.get(str(response_data.status)[0] + "XX", None)
if response_type == "bytearray":
response_data.data = response_data.data
else:
match = None
content_type = response_data.getheader('content-type')
if content_type is not None:
match = re.search(r"charset=([a-zA-Z\-\d]+)[\s;]?", content_type)
encoding = match.group(1) if match else "utf-8"
response_data.data = response_data.data.decode(encoding)
# deserialize response data
if response_type == "bytearray":
return_data = response_data.data
elif response_type:
return_data = self.deserialize(response_data, response_type)
else:
return_data = None
if _return_http_data_only:
return return_data
else:
return ApiResponse(status_code = response_data.status,
data = return_data,
headers = response_data.getheaders(),
raw_data = response_data.data)
def sanitize_for_serialization(self, obj):
"""Builds a JSON POST object.
If obj is None, return None.
If obj is str, int, long, float, bool, return directly.
If obj is datetime.datetime, datetime.date
convert to string in iso8601 format.
If obj is list, sanitize each element in the list.
If obj is dict, return the dict.
If obj is OpenAPI model, return the properties dict.
:param obj: The data to serialize.
:return: The serialized form of data.
"""
if obj is None:
return None
elif isinstance(obj, self.PRIMITIVE_TYPES):
return obj
elif isinstance(obj, list):
return [self.sanitize_for_serialization(sub_obj)
for sub_obj in obj]
elif isinstance(obj, tuple):
return tuple(self.sanitize_for_serialization(sub_obj)
for sub_obj in obj)
elif isinstance(obj, (datetime.datetime, datetime.date)):
return obj.isoformat()
if isinstance(obj, dict):
obj_dict = obj
else:
# Convert model obj to dict except
# attributes `openapi_types`, `attribute_map`
# and attributes which value is not None.
# Convert attribute name to json key in
# model definition for request.
obj_dict = obj.to_dict()
return {key: self.sanitize_for_serialization(val)
for key, val in obj_dict.items()}
def deserialize(self, response, response_type):
"""Deserializes response into an object.
:param response: RESTResponse object to be deserialized.
:param response_type: class literal for
deserialized object, or string of class name.
:return: deserialized object.
"""
# handle file downloading
# save response body into a tmp file and return the instance
if response_type == "file":
return self.__deserialize_file(response)
# fetch data from response object
try:
data = json.loads(response.data)
except ValueError:
data = response.data
return self.__deserialize(data, response_type)
def __deserialize(self, data, klass):
"""Deserializes dict, list, str into an object.
:param data: dict, list or str.
:param klass: class literal, or string of class name.
:return: object.
"""
if data is None:
return None
if isinstance(klass, str):
if klass.startswith('List['):
sub_kls = re.match(r'List\[(.*)]', klass).group(1)
return [self.__deserialize(sub_data, sub_kls)
for sub_data in data]
if klass.startswith('Dict['):
sub_kls = re.match(r'Dict\[([^,]*), (.*)]', klass).group(2)
return {k: self.__deserialize(v, sub_kls)
for k, v in data.items()}
# convert str to class
if klass in self.NATIVE_TYPES_MAPPING:
klass = self.NATIVE_TYPES_MAPPING[klass]
else:
klass = getattr(openapi_client.models, klass)
if klass in self.PRIMITIVE_TYPES:
return self.__deserialize_primitive(data, klass)
elif klass == object:
return self.__deserialize_object(data)
elif klass == datetime.date:
return self.__deserialize_date(data)
elif klass == datetime.datetime:
return self.__deserialize_datetime(data)
else:
return self.__deserialize_model(data, klass)
def call_api(self, resource_path, method,
path_params=None, query_params=None, header_params=None,
body=None, post_params=None, files=None,
response_types_map=None, auth_settings=None,
async_req=None, _return_http_data_only=None,
collection_formats=None, _preload_content=True,
_request_timeout=None, _host=None, _request_auth=None):
"""Makes the HTTP request (synchronous) and returns deserialized data.
To make an async_req request, set the async_req parameter.
:param resource_path: Path to method endpoint.
:param method: Method to call.
:param path_params: Path parameters in the url.
:param query_params: Query parameters in the url.
:param header_params: Header parameters to be
placed in the request header.
:param body: Request body.
:param post_params dict: Request post form parameters,
for `application/x-www-form-urlencoded`, `multipart/form-data`.
:param auth_settings list: Auth Settings names for the request.
:param response: Response data type.
:param files dict: key -> filename, value -> filepath,
for `multipart/form-data`.
:param async_req bool: execute request asynchronously
:param _return_http_data_only: response data instead of ApiResponse
object with status code, headers, etc
:param _preload_content: if False, the ApiResponse.data will
be set to none and raw_data will store the
HTTP response body without reading/decoding.
Default is True.
:param collection_formats: dict of collection formats for path, query,
header, and post parameters.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_token: dict, optional
:return:
If async_req parameter is True,
the request will be called asynchronously.
The method will return the request thread.
If parameter async_req is False or missing,
then the method will return the response directly.
"""
if not async_req:
return self.__call_api(resource_path, method,
path_params, query_params, header_params,
body, post_params, files,
response_types_map, auth_settings,
_return_http_data_only, collection_formats,
_preload_content, _request_timeout, _host,
_request_auth)
return self.pool.apply_async(self.__call_api, (resource_path,
method, path_params,
query_params,
header_params, body,
post_params, files,
response_types_map,
auth_settings,
_return_http_data_only,
collection_formats,
_preload_content,
_request_timeout,
_host, _request_auth))
def request(self, method, url, query_params=None, headers=None,
post_params=None, body=None, _preload_content=True,
_request_timeout=None):
"""Makes the HTTP request using RESTClient."""
if method == "GET":
return self.rest_client.get_request(url,
query_params=query_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
headers=headers)
elif method == "HEAD":
return self.rest_client.head_request(url,
query_params=query_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
headers=headers)
elif method == "OPTIONS":
return self.rest_client.options_request(url,
query_params=query_params,
headers=headers,
_preload_content=_preload_content,
_request_timeout=_request_timeout)
elif method == "POST":
return self.rest_client.post_request(url,
query_params=query_params,
headers=headers,
post_params=post_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
body=body)
elif method == "PUT":
return self.rest_client.put_request(url,
query_params=query_params,
headers=headers,
post_params=post_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
body=body)
elif method == "PATCH":
return self.rest_client.patch_request(url,
query_params=query_params,
headers=headers,
post_params=post_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
body=body)
elif method == "DELETE":
return self.rest_client.delete_request(url,
query_params=query_params,
headers=headers,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
body=body)
else:
raise ApiValueError(
"http method must be `GET`, `HEAD`, `OPTIONS`,"
" `POST`, `PATCH`, `PUT` or `DELETE`."
)
def parameters_to_tuples(self, params, collection_formats):
"""Get parameters as list of tuples, formatting collections.
:param params: Parameters as dict or list of two-tuples
:param dict collection_formats: Parameter collection formats
:return: Parameters as list of tuples, collections formatted
"""
new_params = []
if collection_formats is None:
collection_formats = {}
for k, v in params.items() if isinstance(params, dict) else params: # noqa: E501
if k in collection_formats:
collection_format = collection_formats[k]
if collection_format == 'multi':
new_params.extend((k, value) for value in v)
else:
if collection_format == 'ssv':
delimiter = ' '
elif collection_format == 'tsv':
delimiter = '\t'
elif collection_format == 'pipes':
delimiter = '|'
else: # csv is the default
delimiter = ','
new_params.append(
(k, delimiter.join(str(value) for value in v)))
else:
new_params.append((k, v))
return new_params
def parameters_to_url_query(self, params, collection_formats):
"""Get parameters as list of tuples, formatting collections.
:param params: Parameters as dict or list of two-tuples
:param dict collection_formats: Parameter collection formats
:return: URL query string (e.g. a=Hello%20World&b=123)
"""
new_params = []
if collection_formats is None:
collection_formats = {}
for k, v in params.items() if isinstance(params, dict) else params: # noqa: E501
if isinstance(v, (int, float)):
v = str(v)
if isinstance(v, bool):
v = str(v).lower()
if isinstance(v, dict):
v = json.dumps(v)
if k in collection_formats:
collection_format = collection_formats[k]
if collection_format == 'multi':
new_params.extend((k, value) for value in v)
else:
if collection_format == 'ssv':
delimiter = ' '
elif collection_format == 'tsv':
delimiter = '\t'
elif collection_format == 'pipes':
delimiter = '|'
else: # csv is the default
delimiter = ','
new_params.append(
(k, delimiter.join(quote(str(value)) for value in v)))
else:
new_params.append((k, quote(str(v))))
return "&".join(["=".join(item) for item in new_params])
def files_parameters(self, files=None):
"""Builds form parameters.
:param files: File parameters.
:return: Form parameters with files.
"""
params = []
if files:
for k, v in files.items():
if not v:
continue
file_names = v if type(v) is list else [v]
for n in file_names:
with open(n, 'rb') as f:
filename = os.path.basename(f.name)
filedata = f.read()
mimetype = (mimetypes.guess_type(filename)[0] or
'application/octet-stream')
params.append(
tuple([k, tuple([filename, filedata, mimetype])]))
return params
def select_header_accept(self, accepts):
"""Returns `Accept` based on an array of accepts provided.
:param accepts: List of headers.
:return: Accept (e.g. application/json).
"""
if not accepts:
return
for accept in accepts:
if re.search('json', accept, re.IGNORECASE):
return accept
return accepts[0]
def select_header_content_type(self, content_types):
"""Returns `Content-Type` based on an array of content_types provided.
:param content_types: List of content-types.
:return: Content-Type (e.g. application/json).
"""
if not content_types:
return None
for content_type in content_types:
if re.search('json', content_type, re.IGNORECASE):
return content_type
return content_types[0]
def update_params_for_auth(self, headers, queries, auth_settings,
resource_path, method, body,
request_auth=None):
"""Updates header and query params based on authentication setting.
:param headers: Header parameters dict to be updated.
:param queries: Query parameters tuple list to be updated.
:param auth_settings: Authentication setting identifiers list.
:resource_path: A string representation of the HTTP request resource path.
:method: A string representation of the HTTP request method.
:body: A object representing the body of the HTTP request.
The object type is the return value of sanitize_for_serialization().
:param request_auth: if set, the provided settings will
override the token in the configuration.
"""
if not auth_settings:
return
if request_auth:
self._apply_auth_params(headers, queries,
resource_path, method, body,
request_auth)
return
for auth in auth_settings:
auth_setting = self.configuration.auth_settings().get(auth)
if auth_setting:
self._apply_auth_params(headers, queries,
resource_path, method, body,
auth_setting)
def _apply_auth_params(self, headers, queries,
resource_path, method, body,
auth_setting):
"""Updates the request parameters based on a single auth_setting
:param headers: Header parameters dict to be updated.
:param queries: Query parameters tuple list to be updated.
:resource_path: A string representation of the HTTP request resource path.
:method: A string representation of the HTTP request method.
:body: A object representing the body of the HTTP request.
The object type is the return value of sanitize_for_serialization().
:param auth_setting: auth settings for the endpoint
"""
if auth_setting['in'] == 'cookie':
headers['Cookie'] = auth_setting['value']
elif auth_setting['in'] == 'header':
if auth_setting['type'] != 'http-signature':
headers[auth_setting['key']] = auth_setting['value']
elif auth_setting['in'] == 'query':
queries.append((auth_setting['key'], auth_setting['value']))
else:
raise ApiValueError(
'Authentication token must be in `query` or `header`'
)
def __deserialize_file(self, response):
"""Deserializes body to file
Saves response body into a file in a temporary folder,
using the filename from the `Content-Disposition` header if provided.
:param response: RESTResponse.
:return: file path.
"""
fd, path = tempfile.mkstemp(dir=self.configuration.temp_folder_path)
os.close(fd)
os.remove(path)
content_disposition = response.getheader("Content-Disposition")
if content_disposition:
filename = re.search(r'filename=[\'"]?([^\'"\s]+)[\'"]?',
content_disposition).group(1)
path = os.path.join(os.path.dirname(path), filename)
with open(path, "wb") as f:
f.write(response.data)
return path
def __deserialize_primitive(self, data, klass):
"""Deserializes string to primitive type.
:param data: str.
:param klass: class literal.
:return: int, long, float, str, bool.
"""
try:
return klass(data)
except UnicodeEncodeError:
return str(data)
except TypeError:
return data
def __deserialize_object(self, value):
"""Return an original value.
:return: object.
"""
return value
def __deserialize_date(self, string):
"""Deserializes string to date.
:param string: str.
:return: date.
"""
try:
return parse(string).date()
except ImportError:
return string
except ValueError:
raise rest.ApiException(
status=0,
reason="Failed to parse `{0}` as date object".format(string)
)
def __deserialize_datetime(self, string):
"""Deserializes string to datetime.
The string should be in iso8601 datetime format.
:param string: str.
:return: datetime.
"""
try:
return parse(string)
except ImportError:
return string
except ValueError:
raise rest.ApiException(
status=0,
reason=(
"Failed to parse `{0}` as datetime object"
.format(string)
)
)
def __deserialize_model(self, data, klass):
"""Deserializes list or dict to model.
:param data: dict, list.
:param klass: class literal.
:return: model object.
"""
return klass.from_dict(data)

25
pkgs/clan-cli/tests/openapi_client/api_response.py Normal file
View File

@@ -0,0 +1,25 @@
"""API response object."""
from __future__ import annotations
from typing import Any, Dict, Optional
from pydantic import Field, StrictInt, StrictStr
class ApiResponse:
"""
API response object
"""
status_code: Optional[StrictInt] = Field(None, description="HTTP status code")
headers: Optional[Dict[StrictStr, StrictStr]] = Field(None, description="HTTP headers")
data: Optional[Any] = Field(None, description="Deserialized data given the data type")
raw_data: Optional[Any] = Field(None, description="Raw data (HTTP response body)")
def __init__(self,
status_code=None,
headers=None,
data=None,
raw_data=None) -> None:
self.status_code = status_code
self.headers = headers
self.data = data
self.raw_data = raw_data

434
pkgs/clan-cli/tests/openapi_client/configuration.py Normal file
View File

@@ -0,0 +1,434 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import copy
import logging
import multiprocessing
import sys
import urllib3
import http.client as httplib
JSON_SCHEMA_VALIDATION_KEYWORDS = {
'multipleOf', 'maximum', 'exclusiveMaximum',
'minimum', 'exclusiveMinimum', 'maxLength',
'minLength', 'pattern', 'maxItems', 'minItems'
}
class Configuration:
"""This class contains various settings of the API client.
:param host: Base url.
:param api_key: Dict to store API key(s).
Each entry in the dict specifies an API key.
The dict key is the name of the security scheme in the OAS specification.
The dict value is the API key secret.
:param api_key_prefix: Dict to store API prefix (e.g. Bearer).
The dict key is the name of the security scheme in the OAS specification.
The dict value is an API key prefix when generating the auth data.
:param username: Username for HTTP basic authentication.
:param password: Password for HTTP basic authentication.
:param access_token: Access token.
:param server_index: Index to servers configuration.
:param server_variables: Mapping with string values to replace variables in
templated server configuration. The validation of enums is performed for
variables with defined enum values before.
:param server_operation_index: Mapping from operation ID to an index to server
configuration.
:param server_operation_variables: Mapping from operation ID to a mapping with
string values to replace variables in templated server configuration.
The validation of enums is performed for variables with defined enum
values before.
:param ssl_ca_cert: str - the path to a file of concatenated CA certificates
in PEM format.
"""
_default = None
def __init__(self, host=None,
api_key=None, api_key_prefix=None,
username=None, password=None,
access_token=None,
server_index=None, server_variables=None,
server_operation_index=None, server_operation_variables=None,
ssl_ca_cert=None,
) -> None:
"""Constructor
"""
self._base_path = "http://localhost" if host is None else host
"""Default Base url
"""
self.server_index = 0 if server_index is None and host is None else server_index
self.server_operation_index = server_operation_index or {}
"""Default server index
"""
self.server_variables = server_variables or {}
self.server_operation_variables = server_operation_variables or {}
"""Default server variables
"""
self.temp_folder_path = None
"""Temp file folder for downloading files
"""
# Authentication Settings
self.api_key = {}
if api_key:
self.api_key = api_key
"""dict to store API key(s)
"""
self.api_key_prefix = {}
if api_key_prefix:
self.api_key_prefix = api_key_prefix
"""dict to store API prefix (e.g. Bearer)
"""
self.refresh_api_key_hook = None
"""function hook to refresh API key if expired
"""
self.username = username
"""Username for HTTP basic authentication
"""
self.password = password
"""Password for HTTP basic authentication
"""
self.access_token = access_token
"""Access token
"""
self.logger = {}
"""Logging Settings
"""
self.logger["package_logger"] = logging.getLogger("openapi_client")
self.logger["urllib3_logger"] = logging.getLogger("urllib3")
self.logger_format = '%(asctime)s %(levelname)s %(message)s'
"""Log format
"""
self.logger_stream_handler = None
"""Log stream handler
"""
self.logger_file_handler = None
"""Log file handler
"""
self.logger_file = None
"""Debug file location
"""
self.debug = False
"""Debug switch
"""
self.verify_ssl = True
"""SSL/TLS verification
Set this to false to skip verifying SSL certificate when calling API
from https server.
"""
self.ssl_ca_cert = ssl_ca_cert
"""Set this to customize the certificate file to verify the peer.
"""
self.cert_file = None
"""client certificate file
"""
self.key_file = None
"""client key file
"""
self.assert_hostname = None
"""Set this to True/False to enable/disable SSL hostname verification.
"""
self.tls_server_name = None
"""SSL/TLS Server Name Indication (SNI)
Set this to the SNI value expected by the server.
"""
self.connection_pool_maxsize = multiprocessing.cpu_count() * 5
"""urllib3 connection pool's maximum number of connections saved
per pool. urllib3 uses 1 connection as default value, but this is
not the best value when you are making a lot of possibly parallel
requests to the same host, which is often the case here.
cpu_count * 5 is used as default value to increase performance.
"""
self.proxy = None
"""Proxy URL
"""
self.proxy_headers = None
"""Proxy headers
"""
self.safe_chars_for_path_param = ''
"""Safe chars for path_param
"""
self.retries = None
"""Adding retries to override urllib3 default value 3
"""
# Enable client side validation
self.client_side_validation = True
self.socket_options = None
"""Options to pass down to the underlying urllib3 socket
"""
self.datetime_format = "%Y-%m-%dT%H:%M:%S.%f%z"
"""datetime format
"""
self.date_format = "%Y-%m-%d"
"""date format
"""
def __deepcopy__(self, memo):
cls = self.__class__
result = cls.__new__(cls)
memo[id(self)] = result
for k, v in self.__dict__.items():
if k not in ('logger', 'logger_file_handler'):
setattr(result, k, copy.deepcopy(v, memo))
# shallow copy of loggers
result.logger = copy.copy(self.logger)
# use setters to configure loggers
result.logger_file = self.logger_file
result.debug = self.debug
return result
def __setattr__(self, name, value):
object.__setattr__(self, name, value)
@classmethod
def set_default(cls, default):
"""Set default instance of configuration.
It stores default configuration, which can be
returned by get_default_copy method.
:param default: object of Configuration
"""
cls._default = default
@classmethod
def get_default_copy(cls):
"""Deprecated. Please use `get_default` instead.
Deprecated. Please use `get_default` instead.
:return: The configuration object.
"""
return cls.get_default()
@classmethod
def get_default(cls):
"""Return the default configuration.
This method returns newly created, based on default constructor,
object of Configuration class or returns a copy of default
configuration.
:return: The configuration object.
"""
if cls._default is None:
cls._default = Configuration()
return cls._default
@property
def logger_file(self):
"""The logger file.
If the logger_file is None, then add stream handler and remove file
handler. Otherwise, add file handler and remove stream handler.
:param value: The logger_file path.
:type: str
"""
return self.__logger_file
@logger_file.setter
def logger_file(self, value):
"""The logger file.
If the logger_file is None, then add stream handler and remove file
handler. Otherwise, add file handler and remove stream handler.
:param value: The logger_file path.
:type: str
"""
self.__logger_file = value
if self.__logger_file:
# If set logging file,
# then add file handler and remove stream handler.
self.logger_file_handler = logging.FileHandler(self.__logger_file)
self.logger_file_handler.setFormatter(self.logger_formatter)
for _, logger in self.logger.items():
logger.addHandler(self.logger_file_handler)
@property
def debug(self):
"""Debug status
:param value: The debug status, True or False.
:type: bool
"""
return self.__debug
@debug.setter
def debug(self, value):
"""Debug status
:param value: The debug status, True or False.
:type: bool
"""
self.__debug = value
if self.__debug:
# if debug status is True, turn on debug logging
for _, logger in self.logger.items():
logger.setLevel(logging.DEBUG)
# turn on httplib debug
httplib.HTTPConnection.debuglevel = 1
else:
# if debug status is False, turn off debug logging,
# setting log level to default `logging.WARNING`
for _, logger in self.logger.items():
logger.setLevel(logging.WARNING)
# turn off httplib debug
httplib.HTTPConnection.debuglevel = 0
@property
def logger_format(self):
"""The logger format.
The logger_formatter will be updated when sets logger_format.
:param value: The format string.
:type: str
"""
return self.__logger_format
@logger_format.setter
def logger_format(self, value):
"""The logger format.
The logger_formatter will be updated when sets logger_format.
:param value: The format string.
:type: str
"""
self.__logger_format = value
self.logger_formatter = logging.Formatter(self.__logger_format)
def get_api_key_with_prefix(self, identifier, alias=None):
"""Gets API key (with prefix if set).
:param identifier: The identifier of apiKey.
:param alias: The alternative identifier of apiKey.
:return: The token for api key authentication.
"""
if self.refresh_api_key_hook is not None:
self.refresh_api_key_hook(self)
key = self.api_key.get(identifier, self.api_key.get(alias) if alias is not None else None)
if key:
prefix = self.api_key_prefix.get(identifier)
if prefix:
return "%s %s" % (prefix, key)
else:
return key
def get_basic_auth_token(self):
"""Gets HTTP basic authentication header (string).
:return: The token for basic HTTP authentication.
"""
username = ""
if self.username is not None:
username = self.username
password = ""
if self.password is not None:
password = self.password
return urllib3.util.make_headers(
basic_auth=username + ':' + password
).get('authorization')
def auth_settings(self):
"""Gets Auth Settings dict for api client.
:return: The Auth Settings information dict.
"""
auth = {}
return auth
def to_debug_report(self):
"""Gets the essential information for debugging.
:return: The report for debugging.
"""
return "Python SDK Debug Report:\n"\
"OS: {env}\n"\
"Python Version: {pyversion}\n"\
"Version of the API: 0.1.0\n"\
"SDK Package Version: 1.0.0".\
format(env=sys.platform, pyversion=sys.version)
def get_host_settings(self):
"""Gets an array of host settings
:return: An array of host settings
"""
return [
{
'url': "",
'description': "No description provided",
}
]
def get_host_from_settings(self, index, variables=None, servers=None):
"""Gets host URL based on the index and variables
:param index: array index of the host settings
:param variables: hash of variable and the corresponding value
:param servers: an array of host settings or None
:return: URL based on host settings
"""
if index is None:
return self._base_path
variables = {} if variables is None else variables
servers = self.get_host_settings() if servers is None else servers
try:
server = servers[index]
except IndexError:
raise ValueError(
"Invalid index {0} when selecting the host settings. "
"Must be less than {1}".format(index, len(servers)))
url = server['url']
# go through variables and replace placeholders
for variable_name, variable in server.get('variables', {}).items():
used_value = variables.get(
variable_name, variable['default_value'])
if 'enum_values' in variable \
and used_value not in variable['enum_values']:
raise ValueError(
"The variable `{0}` in the host URL has invalid value "
"{1}. Must be {2}.".format(
variable_name, variables[variable_name],
variable['enum_values']))
url = url.replace("{" + variable_name + "}", used_value)
return url
@property
def host(self):
"""Return generated host."""
return self.get_host_from_settings(self.server_index, variables=self.server_variables)
@host.setter
def host(self, value):
"""Fix base path."""
self._base_path = value
self.server_index = None

193
pkgs/clan-cli/tests/openapi_client/docs/DefaultApi.md Normal file
View File

@@ -0,0 +1,193 @@
# openapi_client.DefaultApi
All URIs are relative to _http://localhost_
| Method | HTTP request | Description |
| ---------------------------------- | -------------------- | ----------- |
| [**get**](DefaultApi.md#get) | **GET** /ws2_example | Get |
| [**health**](DefaultApi.md#health) | **GET** /health | Health |
| [**root**](DefaultApi.md#root) | **GET** /{path_name} | Root |
# **get**
> get()
Get
### Example
```python
import time
import os
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.DefaultApi(api_client)
try:
# Get
api_instance.get()
except Exception as e:
print("Exception when calling DefaultApi->get: %s\n" % e)
```
### Parameters
This endpoint does not need any parameter.
### Return type
void (empty response body)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **health**
> Machine health()
Health
### Example
```python
import time
import os
import openapi_client
from openapi_client.models.machine import Machine
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.DefaultApi(api_client)
try:
# Health
api_response = api_instance.health()
print("The response of DefaultApi->health:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->health: %s\n" % e)
```
### Parameters
This endpoint does not need any parameter.
### Return type
[**Machine**](Machine.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **root**
> root(path_name)
Root
### Example
```python
import time
import os
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.DefaultApi(api_client)
path_name = 'path_name_example' # str |
try:
# Root
api_instance.root(path_name)
except Exception as e:
print("Exception when calling DefaultApi->root: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| ------------- | ------- | ----------- | ----- |
| **path_name** | **str** | |
### Return type
void (empty response body)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

553
pkgs/clan-cli/tests/openapi_client/docs/EntitiesApi.md Normal file
View File

@@ -0,0 +1,553 @@
# openapi_client.EntitiesApi
All URIs are relative to _http://localhost_
| Method | HTTP request | Description |
| ----------------------------------------------------------------- | -------------------------------------- | --------------------- |
| [**attach_entity**](EntitiesApi.md#attach_entity) | **POST** /api/v1/{entity_did}/attach | Attach Entity |
| [**create_entity**](EntitiesApi.md#create_entity) | **POST** /api/v1/entity | Create Entity |
| [**delete_entity**](EntitiesApi.md#delete_entity) | **DELETE** /api/v1/{entity_did}/entity | Delete Entity |
| [**detach_entity**](EntitiesApi.md#detach_entity) | **POST** /api/v1/{entity_did}/detach | Detach Entity |
| [**get_all_entities**](EntitiesApi.md#get_all_entities) | **GET** /api/v1/entities | Get All Entities |
| [**get_attached_entities**](EntitiesApi.md#get_attached_entities) | **GET** /api/v1/attached_entities | Get Attached Entities |
| [**get_entity_by_did**](EntitiesApi.md#get_entity_by_did) | **GET** /api/v1/{entity_did}/entity | Get Entity By Did |
| [**get_entity_by_name**](EntitiesApi.md#get_entity_by_name) | **GET** /api/v1/entity_by_name | Get Entity By Name |
# **attach_entity**
> Dict[str, str] attach_entity(entity_did, skip=skip, limit=limit)
Attach Entity
### Example
```python
import time
import os
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.EntitiesApi(api_client)
entity_did = 'entity_did_example' # str |
skip = 0 # int | (optional) (default to 0)
limit = 100 # int | (optional) (default to 100)
try:
# Attach Entity
api_response = api_instance.attach_entity(entity_did, skip=skip, limit=limit)
print("The response of EntitiesApi->attach_entity:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling EntitiesApi->attach_entity: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| -------------- | ------- | ----------- | --------------------------- |
| **entity_did** | **str** | |
| **skip** | **int** | | [optional] [default to 0] |
| **limit** | **int** | | [optional] [default to 100] |
### Return type
**Dict[str, str]**
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **create_entity**
> Entity create_entity(entity_create)
Create Entity
### Example
```python
import time
import os
import openapi_client
from openapi_client.models.entity import Entity
from openapi_client.models.entity_create import EntityCreate
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.EntitiesApi(api_client)
entity_create = openapi_client.EntityCreate() # EntityCreate |
try:
# Create Entity
api_response = api_instance.create_entity(entity_create)
print("The response of EntitiesApi->create_entity:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling EntitiesApi->create_entity: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| ----------------- | ----------------------------------- | ----------- | ----- |
| **entity_create** | [**EntityCreate**](EntityCreate.md) | |
### Return type
[**Entity**](Entity.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: application/json
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **delete_entity**
> Dict[str, str] delete_entity(entity_did)
Delete Entity
### Example
```python
import time
import os
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.EntitiesApi(api_client)
entity_did = 'entity_did_example' # str |
try:
# Delete Entity
api_response = api_instance.delete_entity(entity_did)
print("The response of EntitiesApi->delete_entity:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling EntitiesApi->delete_entity: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| -------------- | ------- | ----------- | ----- |
| **entity_did** | **str** | |
### Return type
**Dict[str, str]**
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **detach_entity**
> Entity detach_entity(entity_did, skip=skip, limit=limit)
Detach Entity
### Example
```python
import time
import os
import openapi_client
from openapi_client.models.entity import Entity
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.EntitiesApi(api_client)
entity_did = 'entity_did_example' # str |
skip = 0 # int | (optional) (default to 0)
limit = 100 # int | (optional) (default to 100)
try:
# Detach Entity
api_response = api_instance.detach_entity(entity_did, skip=skip, limit=limit)
print("The response of EntitiesApi->detach_entity:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling EntitiesApi->detach_entity: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| -------------- | ------- | ----------- | --------------------------- |
| **entity_did** | **str** | |
| **skip** | **int** | | [optional] [default to 0] |
| **limit** | **int** | | [optional] [default to 100] |
### Return type
[**Entity**](Entity.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **get_all_entities**
> List[Entity] get_all_entities(skip=skip, limit=limit)
Get All Entities
### Example
```python
import time
import os
import openapi_client
from openapi_client.models.entity import Entity
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.EntitiesApi(api_client)
skip = 0 # int | (optional) (default to 0)
limit = 100 # int | (optional) (default to 100)
try:
# Get All Entities
api_response = api_instance.get_all_entities(skip=skip, limit=limit)
print("The response of EntitiesApi->get_all_entities:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling EntitiesApi->get_all_entities: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| --------- | ------- | ----------- | --------------------------- |
| **skip** | **int** | | [optional] [default to 0] |
| **limit** | **int** | | [optional] [default to 100] |
### Return type
[**List[Entity]**](Entity.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **get_attached_entities**
> List[Entity] get_attached_entities(skip=skip, limit=limit)
Get Attached Entities
### Example
```python
import time
import os
import openapi_client
from openapi_client.models.entity import Entity
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.EntitiesApi(api_client)
skip = 0 # int | (optional) (default to 0)
limit = 100 # int | (optional) (default to 100)
try:
# Get Attached Entities
api_response = api_instance.get_attached_entities(skip=skip, limit=limit)
print("The response of EntitiesApi->get_attached_entities:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling EntitiesApi->get_attached_entities: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| --------- | ------- | ----------- | --------------------------- |
| **skip** | **int** | | [optional] [default to 0] |
| **limit** | **int** | | [optional] [default to 100] |
### Return type
[**List[Entity]**](Entity.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **get_entity_by_did**
> Entity get_entity_by_did(entity_did)
Get Entity By Did
### Example
```python
import time
import os
import openapi_client
from openapi_client.models.entity import Entity
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.EntitiesApi(api_client)
entity_did = 'entity_did_example' # str |
try:
# Get Entity By Did
api_response = api_instance.get_entity_by_did(entity_did)
print("The response of EntitiesApi->get_entity_by_did:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling EntitiesApi->get_entity_by_did: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| -------------- | ------- | ----------- | ----- |
| **entity_did** | **str** | |
### Return type
[**Entity**](Entity.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **get_entity_by_name**
> Entity get_entity_by_name(entity_name)
Get Entity By Name
### Example
```python
import time
import os
import openapi_client
from openapi_client.models.entity import Entity
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.EntitiesApi(api_client)
entity_name = 'entity_name_example' # str |
try:
# Get Entity By Name
api_response = api_instance.get_entity_by_name(entity_name)
print("The response of EntitiesApi->get_entity_by_name:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling EntitiesApi->get_entity_by_name: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| --------------- | ------- | ----------- | ----- |
| **entity_name** | **str** | |
### Return type
[**Entity**](Entity.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

32
pkgs/clan-cli/tests/openapi_client/docs/Entity.md Normal file
View File

@@ -0,0 +1,32 @@
# Entity
## Properties
| Name | Type | Description | Notes |
| ------------ | ---------- | ----------- | ----- |
| **did** | **str** | |
| **name** | **str** | |
| **ip** | **str** | |
| **visible** | **bool** | |
| **other** | **object** | |
| **attached** | **bool** | |
## Example
```python
from openapi_client.models.entity import Entity
# TODO update the JSON string below
json = "{}"
# create an instance of Entity from a JSON string
entity_instance = Entity.from_json(json)
# print the JSON string representation of the object
print Entity.to_json()
# convert the object into a dict
entity_dict = entity_instance.to_dict()
# create an instance of Entity from a dict
entity_form_dict = entity.from_dict(entity_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

31
pkgs/clan-cli/tests/openapi_client/docs/EntityCreate.md Normal file
View File

@@ -0,0 +1,31 @@
# EntityCreate
## Properties
| Name | Type | Description | Notes |
| ----------- | ---------- | ----------- | ----- |
| **did** | **str** | |
| **name** | **str** | |
| **ip** | **str** | |
| **visible** | **bool** | |
| **other** | **object** | |
## Example
```python
from openapi_client.models.entity_create import EntityCreate
# TODO update the JSON string below
json = "{}"
# create an instance of EntityCreate from a JSON string
entity_create_instance = EntityCreate.from_json(json)
# print the JSON string representation of the object
print EntityCreate.to_json()
# convert the object into a dict
entity_create_dict = entity_create_instance.to_dict()
# create an instance of EntityCreate from a dict
entity_create_form_dict = entity_create.from_dict(entity_create_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

27
pkgs/clan-cli/tests/openapi_client/docs/HTTPValidationError.md Normal file
View File

@@ -0,0 +1,27 @@
# HTTPValidationError
## Properties
| Name | Type | Description | Notes |
| ---------- | ----------------------------------------------- | ----------- | ---------- |
| **detail** | [**List[ValidationError]**](ValidationError.md) | | [optional] |
## Example
```python
from openapi_client.models.http_validation_error import HTTPValidationError
# TODO update the JSON string below
json = "{}"
# create an instance of HTTPValidationError from a JSON string
http_validation_error_instance = HTTPValidationError.from_json(json)
# print the JSON string representation of the object
print HTTPValidationError.to_json()
# convert the object into a dict
http_validation_error_dict = http_validation_error_instance.to_dict()
# create an instance of HTTPValidationError from a dict
http_validation_error_form_dict = http_validation_error.from_dict(http_validation_error_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

28
pkgs/clan-cli/tests/openapi_client/docs/Machine.md Normal file
View File

@@ -0,0 +1,28 @@
# Machine
## Properties
| Name | Type | Description | Notes |
| ---------- | ----------------------- | ----------- | ----- |
| **name** | **str** | |
| **status** | [**Status**](Status.md) | |
## Example
```python
from openapi_client.models.machine import Machine
# TODO update the JSON string below
json = "{}"
# create an instance of Machine from a JSON string
machine_instance = Machine.from_json(json)
# print the JSON string representation of the object
print Machine.to_json()
# convert the object into a dict
machine_dict = machine_instance.to_dict()
# create an instance of Machine from a dict
machine_form_dict = machine.from_dict(machine_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

75
pkgs/clan-cli/tests/openapi_client/docs/RepositoriesApi.md Normal file
View File

@@ -0,0 +1,75 @@
# openapi_client.RepositoriesApi
All URIs are relative to _http://localhost_
| Method | HTTP request | Description |
| ------------------------------------------------------------------- | ---------------------------- | -------------------- |
| [**get_all_repositories**](RepositoriesApi.md#get_all_repositories) | **GET** /api/v1/repositories | Get All Repositories |
# **get_all_repositories**
> List[Service] get_all_repositories(skip=skip, limit=limit)
Get All Repositories
### Example
```python
import time
import os
import openapi_client
from openapi_client.models.service import Service
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.RepositoriesApi(api_client)
skip = 0 # int | (optional) (default to 0)
limit = 100 # int | (optional) (default to 100)
try:
# Get All Repositories
api_response = api_instance.get_all_repositories(skip=skip, limit=limit)
print("The response of RepositoriesApi->get_all_repositories:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling RepositoriesApi->get_all_repositories: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| --------- | ------- | ----------- | --------------------------- |
| **skip** | **int** | | [optional] [default to 0] |
| **limit** | **int** | | [optional] [default to 100] |
### Return type
[**List[Service]**](Service.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

32
pkgs/clan-cli/tests/openapi_client/docs/Resolution.md Normal file
View File

@@ -0,0 +1,32 @@
# Resolution
## Properties
| Name | Type | Description | Notes |
| ------------------ | ------------ | ----------- | ----- |
| **requester_name** | **str** | |
| **requester_did** | **str** | |
| **resolved_did** | **str** | |
| **other** | **object** | |
| **timestamp** | **datetime** | |
| **id** | **int** | |
## Example
```python
from openapi_client.models.resolution import Resolution
# TODO update the JSON string below
json = "{}"
# create an instance of Resolution from a JSON string
resolution_instance = Resolution.from_json(json)
# print the JSON string representation of the object
print Resolution.to_json()
# convert the object into a dict
resolution_dict = resolution_instance.to_dict()
# create an instance of Resolution from a dict
resolution_form_dict = resolution.from_dict(resolution_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

75
pkgs/clan-cli/tests/openapi_client/docs/ResolutionApi.md Normal file
View File

@@ -0,0 +1,75 @@
# openapi_client.ResolutionApi
All URIs are relative to _http://localhost_
| Method | HTTP request | Description |
| --------------------------------------------------------------- | --------------------------- | ------------------- |
| [**get_all_resolutions**](ResolutionApi.md#get_all_resolutions) | **GET** /api/v1/resolutions | Get All Resolutions |
# **get_all_resolutions**
> List[Resolution] get_all_resolutions(skip=skip, limit=limit)
Get All Resolutions
### Example
```python
import time
import os
import openapi_client
from openapi_client.models.resolution import Resolution
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.ResolutionApi(api_client)
skip = 0 # int | (optional) (default to 0)
limit = 100 # int | (optional) (default to 100)
try:
# Get All Resolutions
api_response = api_instance.get_all_resolutions(skip=skip, limit=limit)
print("The response of ResolutionApi->get_all_resolutions:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling ResolutionApi->get_all_resolutions: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| --------- | ------- | ----------- | --------------------------- |
| **skip** | **int** | | [optional] [default to 0] |
| **limit** | **int** | | [optional] [default to 100] |
### Return type
[**List[Resolution]**](Resolution.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

34
pkgs/clan-cli/tests/openapi_client/docs/Service.md Normal file
View File

@@ -0,0 +1,34 @@
# Service
## Properties
| Name | Type | Description | Notes |
| ---------------- | ----------------------- | ----------- | ----- |
| **uuid** | **str** | |
| **service_name** | **str** | |
| **service_type** | **str** | |
| **endpoint_url** | **str** | |
| **status** | **str** | |
| **other** | **object** | |
| **entity_did** | **str** | |
| **entity** | [**Entity**](Entity.md) | |
## Example
```python
from openapi_client.models.service import Service
# TODO update the JSON string below
json = "{}"
# create an instance of Service from a JSON string
service_instance = Service.from_json(json)
# print the JSON string representation of the object
print Service.to_json()
# convert the object into a dict
service_dict = service_instance.to_dict()
# create an instance of Service from a dict
service_form_dict = service.from_dict(service_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

33
pkgs/clan-cli/tests/openapi_client/docs/ServiceCreate.md Normal file
View File

@@ -0,0 +1,33 @@
# ServiceCreate
## Properties
| Name | Type | Description | Notes |
| ---------------- | ---------- | ----------- | ----- |
| **uuid** | **str** | |
| **service_name** | **str** | |
| **service_type** | **str** | |
| **endpoint_url** | **str** | |
| **status** | **str** | |
| **other** | **object** | |
| **entity_did** | **str** | |
## Example
```python
from openapi_client.models.service_create import ServiceCreate
# TODO update the JSON string below
json = "{}"
# create an instance of ServiceCreate from a JSON string
service_create_instance = ServiceCreate.from_json(json)
# print the JSON string representation of the object
print ServiceCreate.to_json()
# convert the object into a dict
service_create_dict = service_create_instance.to_dict()
# create an instance of ServiceCreate from a dict
service_create_form_dict = service_create.from_dict(service_create_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

351
pkgs/clan-cli/tests/openapi_client/docs/ServicesApi.md Normal file
View File

@@ -0,0 +1,351 @@
# openapi_client.ServicesApi
All URIs are relative to _http://localhost_
| Method | HTTP request | Description |
| --------------------------------------------------------------- | --------------------------------------- | -------------------- |
| [**create_service**](ServicesApi.md#create_service) | **POST** /api/v1/service | Create Service |
| [**delete_service**](ServicesApi.md#delete_service) | **DELETE** /api/v1/{entity_did}/service | Delete Service |
| [**get_all_services**](ServicesApi.md#get_all_services) | **GET** /api/v1/services | Get All Services |
| [**get_service_by_did**](ServicesApi.md#get_service_by_did) | **GET** /api/v1/{entity_did}/service | Get Service By Did |
| [**get_services_by_name**](ServicesApi.md#get_services_by_name) | **GET** /api/v1/services_by_entity_name | Get Services By Name |
# **create_service**
> Service create_service(service_create)
Create Service
### Example
```python
import time
import os
import openapi_client
from openapi_client.models.service import Service
from openapi_client.models.service_create import ServiceCreate
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.ServicesApi(api_client)
service_create = openapi_client.ServiceCreate() # ServiceCreate |
try:
# Create Service
api_response = api_instance.create_service(service_create)
print("The response of ServicesApi->create_service:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling ServicesApi->create_service: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| ------------------ | ------------------------------------- | ----------- | ----- |
| **service_create** | [**ServiceCreate**](ServiceCreate.md) | |
### Return type
[**Service**](Service.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: application/json
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **delete_service**
> Dict[str, str] delete_service(entity_did)
Delete Service
### Example
```python
import time
import os
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.ServicesApi(api_client)
entity_did = 'entity_did_example' # str |
try:
# Delete Service
api_response = api_instance.delete_service(entity_did)
print("The response of ServicesApi->delete_service:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling ServicesApi->delete_service: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| -------------- | ------- | ----------- | ----- |
| **entity_did** | **str** | |
### Return type
**Dict[str, str]**
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **get_all_services**
> List[Service] get_all_services(skip=skip, limit=limit)
Get All Services
### Example
```python
import time
import os
import openapi_client
from openapi_client.models.service import Service
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.ServicesApi(api_client)
skip = 0 # int | (optional) (default to 0)
limit = 100 # int | (optional) (default to 100)
try:
# Get All Services
api_response = api_instance.get_all_services(skip=skip, limit=limit)
print("The response of ServicesApi->get_all_services:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling ServicesApi->get_all_services: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| --------- | ------- | ----------- | --------------------------- |
| **skip** | **int** | | [optional] [default to 0] |
| **limit** | **int** | | [optional] [default to 100] |
### Return type
[**List[Service]**](Service.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **get_service_by_did**
> List[Service] get_service_by_did(entity_did, skip=skip, limit=limit)
Get Service By Did
### Example
```python
import time
import os
import openapi_client
from openapi_client.models.service import Service
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.ServicesApi(api_client)
entity_did = 'entity_did_example' # str |
skip = 0 # int | (optional) (default to 0)
limit = 100 # int | (optional) (default to 100)
try:
# Get Service By Did
api_response = api_instance.get_service_by_did(entity_did, skip=skip, limit=limit)
print("The response of ServicesApi->get_service_by_did:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling ServicesApi->get_service_by_did: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| -------------- | ------- | ----------- | --------------------------- |
| **entity_did** | **str** | |
| **skip** | **int** | | [optional] [default to 0] |
| **limit** | **int** | | [optional] [default to 100] |
### Return type
[**List[Service]**](Service.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **get_services_by_name**
> ServicesByName get_services_by_name(entity_name, skip=skip, limit=limit)
Get Services By Name
### Example
```python
import time
import os
import openapi_client
from openapi_client.models.services_by_name import ServicesByName
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.ServicesApi(api_client)
entity_name = 'entity_name_example' # str |
skip = 0 # int | (optional) (default to 0)
limit = 100 # int | (optional) (default to 100)
try:
# Get Services By Name
api_response = api_instance.get_services_by_name(entity_name, skip=skip, limit=limit)
print("The response of ServicesApi->get_services_by_name:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling ServicesApi->get_services_by_name: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| --------------- | ------- | ----------- | --------------------------- |
| **entity_name** | **str** | |
| **skip** | **int** | | [optional] [default to 0] |
| **limit** | **int** | | [optional] [default to 100] |
### Return type
[**ServicesByName**](ServicesByName.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

28
pkgs/clan-cli/tests/openapi_client/docs/ServicesByName.md Normal file
View File

@@ -0,0 +1,28 @@
# ServicesByName
## Properties
| Name | Type | Description | Notes |
| ------------ | ------------------------------- | ----------- | ----- |
| **entity** | [**Entity**](Entity.md) | |
| **services** | [**List[Service]**](Service.md) | |
## Example
```python
from openapi_client.models.services_by_name import ServicesByName
# TODO update the JSON string below
json = "{}"
# create an instance of ServicesByName from a JSON string
services_by_name_instance = ServicesByName.from_json(json)
# print the JSON string representation of the object
print ServicesByName.to_json()
# convert the object into a dict
services_by_name_dict = services_by_name_instance.to_dict()
# create an instance of ServicesByName from a dict
services_by_name_form_dict = services_by_name.from_dict(services_by_name_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

10
pkgs/clan-cli/tests/openapi_client/docs/Status.md Normal file
View File

@@ -0,0 +1,10 @@
# Status
An enumeration.
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

29
pkgs/clan-cli/tests/openapi_client/docs/ValidationError.md Normal file
View File

@@ -0,0 +1,29 @@
# ValidationError
## Properties
| Name | Type | Description | Notes |
| -------- | --------------------------------------------------------------- | ----------- | ----- |
| **loc** | [**List[ValidationErrorLocInner]**](ValidationErrorLocInner.md) | |
| **msg** | **str** | |
| **type** | **str** | |
## Example
```python
from openapi_client.models.validation_error import ValidationError
# TODO update the JSON string below
json = "{}"
# create an instance of ValidationError from a JSON string
validation_error_instance = ValidationError.from_json(json)
# print the JSON string representation of the object
print ValidationError.to_json()
# convert the object into a dict
validation_error_dict = validation_error_instance.to_dict()
# create an instance of ValidationError from a dict
validation_error_form_dict = validation_error.from_dict(validation_error_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

26
pkgs/clan-cli/tests/openapi_client/docs/ValidationErrorLocInner.md Normal file
View File

@@ -0,0 +1,26 @@
# ValidationErrorLocInner
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
## Example
```python
from openapi_client.models.validation_error_loc_inner import ValidationErrorLocInner
# TODO update the JSON string below
json = "{}"
# create an instance of ValidationErrorLocInner from a JSON string
validation_error_loc_inner_instance = ValidationErrorLocInner.from_json(json)
# print the JSON string representation of the object
print ValidationErrorLocInner.to_json()
# convert the object into a dict
validation_error_loc_inner_dict = validation_error_loc_inner_instance.to_dict()
# create an instance of ValidationErrorLocInner from a dict
validation_error_loc_inner_form_dict = validation_error_loc_inner.from_dict(validation_error_loc_inner_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

166
pkgs/clan-cli/tests/openapi_client/exceptions.py Normal file
View File

@@ -0,0 +1,166 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
class OpenApiException(Exception):
"""The base exception class for all OpenAPIExceptions"""
class ApiTypeError(OpenApiException, TypeError):
def __init__(self, msg, path_to_item=None, valid_classes=None,
key_type=None) -> None:
""" Raises an exception for TypeErrors
Args:
msg (str): the exception message
Keyword Args:
path_to_item (list): a list of keys an indices to get to the
current_item
None if unset
valid_classes (tuple): the primitive classes that current item
should be an instance of
None if unset
key_type (bool): False if our value is a value in a dict
True if it is a key in a dict
False if our item is an item in a list
None if unset
"""
self.path_to_item = path_to_item
self.valid_classes = valid_classes
self.key_type = key_type
full_msg = msg
if path_to_item:
full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
super(ApiTypeError, self).__init__(full_msg)
class ApiValueError(OpenApiException, ValueError):
def __init__(self, msg, path_to_item=None) -> None:
"""
Args:
msg (str): the exception message
Keyword Args:
path_to_item (list) the path to the exception in the
received_data dict. None if unset
"""
self.path_to_item = path_to_item
full_msg = msg
if path_to_item:
full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
super(ApiValueError, self).__init__(full_msg)
class ApiAttributeError(OpenApiException, AttributeError):
def __init__(self, msg, path_to_item=None) -> None:
"""
Raised when an attribute reference or assignment fails.
Args:
msg (str): the exception message
Keyword Args:
path_to_item (None/list) the path to the exception in the
received_data dict
"""
self.path_to_item = path_to_item
full_msg = msg
if path_to_item:
full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
super(ApiAttributeError, self).__init__(full_msg)
class ApiKeyError(OpenApiException, KeyError):
def __init__(self, msg, path_to_item=None) -> None:
"""
Args:
msg (str): the exception message
Keyword Args:
path_to_item (None/list) the path to the exception in the
received_data dict
"""
self.path_to_item = path_to_item
full_msg = msg
if path_to_item:
full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
super(ApiKeyError, self).__init__(full_msg)
class ApiException(OpenApiException):
def __init__(self, status=None, reason=None, http_resp=None) -> None:
if http_resp:
self.status = http_resp.status
self.reason = http_resp.reason
self.body = http_resp.data
self.headers = http_resp.getheaders()
else:
self.status = status
self.reason = reason
self.body = None
self.headers = None
def __str__(self):
"""Custom error messages for exception"""
error_message = "({0})\n"\
"Reason: {1}\n".format(self.status, self.reason)
if self.headers:
error_message += "HTTP response headers: {0}\n".format(
self.headers)
if self.body:
error_message += "HTTP response body: {0}\n".format(self.body)
return error_message
class BadRequestException(ApiException):
def __init__(self, status=None, reason=None, http_resp=None) -> None:
super(BadRequestException, self).__init__(status, reason, http_resp)
class NotFoundException(ApiException):
def __init__(self, status=None, reason=None, http_resp=None) -> None:
super(NotFoundException, self).__init__(status, reason, http_resp)
class UnauthorizedException(ApiException):
def __init__(self, status=None, reason=None, http_resp=None) -> None:
super(UnauthorizedException, self).__init__(status, reason, http_resp)
class ForbiddenException(ApiException):
def __init__(self, status=None, reason=None, http_resp=None) -> None:
super(ForbiddenException, self).__init__(status, reason, http_resp)
class ServiceException(ApiException):
def __init__(self, status=None, reason=None, http_resp=None) -> None:
super(ServiceException, self).__init__(status, reason, http_resp)
def render_path(path_to_item):
"""Returns a string representation of a path"""
result = ""
for pth in path_to_item:
if isinstance(pth, int):
result += "[{0}]".format(pth)
else:
result += "['{0}']".format(pth)
return result

27
pkgs/clan-cli/tests/openapi_client/models/__init__.py Normal file
View File

@@ -0,0 +1,27 @@
# coding: utf-8
# flake8: noqa
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
# import models into model package
from openapi_client.models.entity import Entity
from openapi_client.models.entity_create import EntityCreate
from openapi_client.models.http_validation_error import HTTPValidationError
from openapi_client.models.machine import Machine
from openapi_client.models.resolution import Resolution
from openapi_client.models.service import Service
from openapi_client.models.service_create import ServiceCreate
from openapi_client.models.services_by_name import ServicesByName
from openapi_client.models.status import Status
from openapi_client.models.validation_error import ValidationError
from openapi_client.models.validation_error_loc_inner import ValidationErrorLocInner

81
pkgs/clan-cli/tests/openapi_client/models/entity.py Normal file
View File

@@ -0,0 +1,81 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
from __future__ import annotations
import pprint
import re # noqa: F401
import json
from typing import Any, Dict
from pydantic import BaseModel, Field, StrictBool, StrictStr
class Entity(BaseModel):
"""
Entity
"""
did: StrictStr = Field(...)
name: StrictStr = Field(...)
ip: StrictStr = Field(...)
visible: StrictBool = Field(...)
other: Dict[str, Any] = Field(...)
attached: StrictBool = Field(...)
__properties = ["did", "name", "ip", "visible", "other", "attached"]
class Config:
"""Pydantic configuration"""
allow_population_by_field_name = True
validate_assignment = True
def to_str(self) -> str:
"""Returns the string representation of the model using alias"""
return pprint.pformat(self.dict(by_alias=True))
def to_json(self) -> str:
"""Returns the JSON representation of the model using alias"""
return json.dumps(self.to_dict())
@classmethod
def from_json(cls, json_str: str) -> Entity:
"""Create an instance of Entity from a JSON string"""
return cls.from_dict(json.loads(json_str))
def to_dict(self):
"""Returns the dictionary representation of the model using alias"""
_dict = self.dict(by_alias=True,
exclude={
},
exclude_none=True)
return _dict
@classmethod
def from_dict(cls, obj: dict) -> Entity:
"""Create an instance of Entity from a dict"""
if obj is None:
return None
if not isinstance(obj, dict):
return Entity.parse_obj(obj)
_obj = Entity.parse_obj({
"did": obj.get("did"),
"name": obj.get("name"),
"ip": obj.get("ip"),
"visible": obj.get("visible"),
"other": obj.get("other"),
"attached": obj.get("attached")
})
return _obj

79
pkgs/clan-cli/tests/openapi_client/models/entity_create.py Normal file
View File

@@ -0,0 +1,79 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
from __future__ import annotations
import pprint
import re # noqa: F401
import json
from typing import Any, Dict
from pydantic import BaseModel, Field, StrictBool, StrictStr
class EntityCreate(BaseModel):
"""
EntityCreate
"""
did: StrictStr = Field(...)
name: StrictStr = Field(...)
ip: StrictStr = Field(...)
visible: StrictBool = Field(...)
other: Dict[str, Any] = Field(...)
__properties = ["did", "name", "ip", "visible", "other"]
class Config:
"""Pydantic configuration"""
allow_population_by_field_name = True
validate_assignment = True
def to_str(self) -> str:
"""Returns the string representation of the model using alias"""
return pprint.pformat(self.dict(by_alias=True))
def to_json(self) -> str:
"""Returns the JSON representation of the model using alias"""
return json.dumps(self.to_dict())
@classmethod
def from_json(cls, json_str: str) -> EntityCreate:
"""Create an instance of EntityCreate from a JSON string"""
return cls.from_dict(json.loads(json_str))
def to_dict(self):
"""Returns the dictionary representation of the model using alias"""
_dict = self.dict(by_alias=True,
exclude={
},
exclude_none=True)
return _dict
@classmethod
def from_dict(cls, obj: dict) -> EntityCreate:
"""Create an instance of EntityCreate from a dict"""
if obj is None:
return None
if not isinstance(obj, dict):
return EntityCreate.parse_obj(obj)
_obj = EntityCreate.parse_obj({
"did": obj.get("did"),
"name": obj.get("name"),
"ip": obj.get("ip"),
"visible": obj.get("visible"),
"other": obj.get("other")
})
return _obj

79
pkgs/clan-cli/tests/openapi_client/models/http_validation_error.py Normal file
View File

@@ -0,0 +1,79 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
from __future__ import annotations
import pprint
import re # noqa: F401
import json
from typing import List, Optional
from pydantic import BaseModel, conlist
from openapi_client.models.validation_error import ValidationError
class HTTPValidationError(BaseModel):
"""
HTTPValidationError
"""
detail: Optional[conlist(ValidationError)] = None
__properties = ["detail"]
class Config:
"""Pydantic configuration"""
allow_population_by_field_name = True
validate_assignment = True
def to_str(self) -> str:
"""Returns the string representation of the model using alias"""
return pprint.pformat(self.dict(by_alias=True))
def to_json(self) -> str:
"""Returns the JSON representation of the model using alias"""
return json.dumps(self.to_dict())
@classmethod
def from_json(cls, json_str: str) -> HTTPValidationError:
"""Create an instance of HTTPValidationError from a JSON string"""
return cls.from_dict(json.loads(json_str))
def to_dict(self):
"""Returns the dictionary representation of the model using alias"""
_dict = self.dict(by_alias=True,
exclude={
},
exclude_none=True)
# override the default output from pydantic by calling `to_dict()` of each item in detail (list)
_items = []
if self.detail:
for _item in self.detail:
if _item:
_items.append(_item.to_dict())
_dict['detail'] = _items
return _dict
@classmethod
def from_dict(cls, obj: dict) -> HTTPValidationError:
"""Create an instance of HTTPValidationError from a dict"""
if obj is None:
return None
if not isinstance(obj, dict):
return HTTPValidationError.parse_obj(obj)
_obj = HTTPValidationError.parse_obj({
"detail": [ValidationError.from_dict(_item) for _item in obj.get("detail")] if obj.get("detail") is not None else None
})
return _obj

74
pkgs/clan-cli/tests/openapi_client/models/machine.py Normal file
View File

@@ -0,0 +1,74 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
from __future__ import annotations
import pprint
import re # noqa: F401
import json
from pydantic import BaseModel, Field, StrictStr
from openapi_client.models.status import Status
class Machine(BaseModel):
"""
Machine
"""
name: StrictStr = Field(...)
status: Status = Field(...)
__properties = ["name", "status"]
class Config:
"""Pydantic configuration"""
allow_population_by_field_name = True
validate_assignment = True
def to_str(self) -> str:
"""Returns the string representation of the model using alias"""
return pprint.pformat(self.dict(by_alias=True))
def to_json(self) -> str:
"""Returns the JSON representation of the model using alias"""
return json.dumps(self.to_dict())
@classmethod
def from_json(cls, json_str: str) -> Machine:
"""Create an instance of Machine from a JSON string"""
return cls.from_dict(json.loads(json_str))
def to_dict(self):
"""Returns the dictionary representation of the model using alias"""
_dict = self.dict(by_alias=True,
exclude={
},
exclude_none=True)
return _dict
@classmethod
def from_dict(cls, obj: dict) -> Machine:
"""Create an instance of Machine from a dict"""
if obj is None:
return None
if not isinstance(obj, dict):
return Machine.parse_obj(obj)
_obj = Machine.parse_obj({
"name": obj.get("name"),
"status": obj.get("status")
})
return _obj

81
pkgs/clan-cli/tests/openapi_client/models/resolution.py Normal file
View File

@@ -0,0 +1,81 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
from __future__ import annotations
import pprint
import re # noqa: F401
import json
from datetime import datetime
from typing import Any, Dict
from pydantic import BaseModel, Field, StrictInt, StrictStr
class Resolution(BaseModel):
"""
Resolution
"""
requester_name: StrictStr = Field(...)
requester_did: StrictStr = Field(...)
resolved_did: StrictStr = Field(...)
other: Dict[str, Any] = Field(...)
timestamp: datetime = Field(...)
id: StrictInt = Field(...)
__properties = ["requester_name", "requester_did", "resolved_did", "other", "timestamp", "id"]
class Config:
"""Pydantic configuration"""
allow_population_by_field_name = True
validate_assignment = True
def to_str(self) -> str:
"""Returns the string representation of the model using alias"""
return pprint.pformat(self.dict(by_alias=True))
def to_json(self) -> str:
"""Returns the JSON representation of the model using alias"""
return json.dumps(self.to_dict())
@classmethod
def from_json(cls, json_str: str) -> Resolution:
"""Create an instance of Resolution from a JSON string"""
return cls.from_dict(json.loads(json_str))
def to_dict(self):
"""Returns the dictionary representation of the model using alias"""
_dict = self.dict(by_alias=True,
exclude={
},
exclude_none=True)
return _dict
@classmethod
def from_dict(cls, obj: dict) -> Resolution:
"""Create an instance of Resolution from a dict"""
if obj is None:
return None
if not isinstance(obj, dict):
return Resolution.parse_obj(obj)
_obj = Resolution.parse_obj({
"requester_name": obj.get("requester_name"),
"requester_did": obj.get("requester_did"),
"resolved_did": obj.get("resolved_did"),
"other": obj.get("other"),
"timestamp": obj.get("timestamp"),
"id": obj.get("id")
})
return _obj

89
pkgs/clan-cli/tests/openapi_client/models/service.py Normal file
View File

@@ -0,0 +1,89 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
from __future__ import annotations
import pprint
import re # noqa: F401
import json
from typing import Any, Dict
from pydantic import BaseModel, Field, StrictStr
from openapi_client.models.entity import Entity
class Service(BaseModel):
"""
Service
"""
uuid: StrictStr = Field(...)
service_name: StrictStr = Field(...)
service_type: StrictStr = Field(...)
endpoint_url: StrictStr = Field(...)
status: StrictStr = Field(...)
other: Dict[str, Any] = Field(...)
entity_did: StrictStr = Field(...)
entity: Entity = Field(...)
__properties = ["uuid", "service_name", "service_type", "endpoint_url", "status", "other", "entity_did", "entity"]
class Config:
"""Pydantic configuration"""
allow_population_by_field_name = True
validate_assignment = True
def to_str(self) -> str:
"""Returns the string representation of the model using alias"""
return pprint.pformat(self.dict(by_alias=True))
def to_json(self) -> str:
"""Returns the JSON representation of the model using alias"""
return json.dumps(self.to_dict())
@classmethod
def from_json(cls, json_str: str) -> Service:
"""Create an instance of Service from a JSON string"""
return cls.from_dict(json.loads(json_str))
def to_dict(self):
"""Returns the dictionary representation of the model using alias"""
_dict = self.dict(by_alias=True,
exclude={
},
exclude_none=True)
# override the default output from pydantic by calling `to_dict()` of entity
if self.entity:
_dict['entity'] = self.entity.to_dict()
return _dict
@classmethod
def from_dict(cls, obj: dict) -> Service:
"""Create an instance of Service from a dict"""
if obj is None:
return None
if not isinstance(obj, dict):
return Service.parse_obj(obj)
_obj = Service.parse_obj({
"uuid": obj.get("uuid"),
"service_name": obj.get("service_name"),
"service_type": obj.get("service_type"),
"endpoint_url": obj.get("endpoint_url"),
"status": obj.get("status"),
"other": obj.get("other"),
"entity_did": obj.get("entity_did"),
"entity": Entity.from_dict(obj.get("entity")) if obj.get("entity") is not None else None
})
return _obj

83
pkgs/clan-cli/tests/openapi_client/models/service_create.py Normal file
View File

@@ -0,0 +1,83 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
from __future__ import annotations
import pprint
import re # noqa: F401
import json
from typing import Any, Dict
from pydantic import BaseModel, Field, StrictStr
class ServiceCreate(BaseModel):
"""
ServiceCreate
"""
uuid: StrictStr = Field(...)
service_name: StrictStr = Field(...)
service_type: StrictStr = Field(...)
endpoint_url: StrictStr = Field(...)
status: StrictStr = Field(...)
other: Dict[str, Any] = Field(...)
entity_did: StrictStr = Field(...)
__properties = ["uuid", "service_name", "service_type", "endpoint_url", "status", "other", "entity_did"]
class Config:
"""Pydantic configuration"""
allow_population_by_field_name = True
validate_assignment = True
def to_str(self) -> str:
"""Returns the string representation of the model using alias"""
return pprint.pformat(self.dict(by_alias=True))
def to_json(self) -> str:
"""Returns the JSON representation of the model using alias"""
return json.dumps(self.to_dict())
@classmethod
def from_json(cls, json_str: str) -> ServiceCreate:
"""Create an instance of ServiceCreate from a JSON string"""
return cls.from_dict(json.loads(json_str))
def to_dict(self):
"""Returns the dictionary representation of the model using alias"""
_dict = self.dict(by_alias=True,
exclude={
},
exclude_none=True)
return _dict
@classmethod
def from_dict(cls, obj: dict) -> ServiceCreate:
"""Create an instance of ServiceCreate from a dict"""
if obj is None:
return None
if not isinstance(obj, dict):
return ServiceCreate.parse_obj(obj)
_obj = ServiceCreate.parse_obj({
"uuid": obj.get("uuid"),
"service_name": obj.get("service_name"),
"service_type": obj.get("service_type"),
"endpoint_url": obj.get("endpoint_url"),
"status": obj.get("status"),
"other": obj.get("other"),
"entity_did": obj.get("entity_did")
})
return _obj

85
pkgs/clan-cli/tests/openapi_client/models/services_by_name.py Normal file
View File

@@ -0,0 +1,85 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
from __future__ import annotations
import pprint
import re # noqa: F401
import json
from typing import List
from pydantic import BaseModel, Field, conlist
from openapi_client.models.entity import Entity
from openapi_client.models.service import Service
class ServicesByName(BaseModel):
"""
ServicesByName
"""
entity: Entity = Field(...)
services: conlist(Service) = Field(...)
__properties = ["entity", "services"]
class Config:
"""Pydantic configuration"""
allow_population_by_field_name = True
validate_assignment = True
def to_str(self) -> str:
"""Returns the string representation of the model using alias"""
return pprint.pformat(self.dict(by_alias=True))
def to_json(self) -> str:
"""Returns the JSON representation of the model using alias"""
return json.dumps(self.to_dict())
@classmethod
def from_json(cls, json_str: str) -> ServicesByName:
"""Create an instance of ServicesByName from a JSON string"""
return cls.from_dict(json.loads(json_str))
def to_dict(self):
"""Returns the dictionary representation of the model using alias"""
_dict = self.dict(by_alias=True,
exclude={
},
exclude_none=True)
# override the default output from pydantic by calling `to_dict()` of entity
if self.entity:
_dict['entity'] = self.entity.to_dict()
# override the default output from pydantic by calling `to_dict()` of each item in services (list)
_items = []
if self.services:
for _item in self.services:
if _item:
_items.append(_item.to_dict())
_dict['services'] = _items
return _dict
@classmethod
def from_dict(cls, obj: dict) -> ServicesByName:
"""Create an instance of ServicesByName from a dict"""
if obj is None:
return None
if not isinstance(obj, dict):
return ServicesByName.parse_obj(obj)
_obj = ServicesByName.parse_obj({
"entity": Entity.from_dict(obj.get("entity")) if obj.get("entity") is not None else None,
"services": [Service.from_dict(_item) for _item in obj.get("services")] if obj.get("services") is not None else None
})
return _obj

41
pkgs/clan-cli/tests/openapi_client/models/status.py Normal file
View File

@@ -0,0 +1,41 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import json
import pprint
import re # noqa: F401
from aenum import Enum, no_arg
class Status(str, Enum):
"""
An enumeration.
"""
"""
allowed enum values
"""
ONLINE = 'online'
OFFLINE = 'offline'
UNKNOWN = 'unknown'
@classmethod
def from_json(cls, json_str: str) -> Status:
"""Create an instance of Status from a JSON string"""
return Status(json.loads(json_str))

83
pkgs/clan-cli/tests/openapi_client/models/validation_error.py Normal file
View File

@@ -0,0 +1,83 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
from __future__ import annotations
import pprint
import re # noqa: F401
import json
from typing import List
from pydantic import BaseModel, Field, StrictStr, conlist
from openapi_client.models.validation_error_loc_inner import ValidationErrorLocInner
class ValidationError(BaseModel):
"""
ValidationError
"""
loc: conlist(ValidationErrorLocInner) = Field(...)
msg: StrictStr = Field(...)
type: StrictStr = Field(...)
__properties = ["loc", "msg", "type"]
class Config:
"""Pydantic configuration"""
allow_population_by_field_name = True
validate_assignment = True
def to_str(self) -> str:
"""Returns the string representation of the model using alias"""
return pprint.pformat(self.dict(by_alias=True))
def to_json(self) -> str:
"""Returns the JSON representation of the model using alias"""
return json.dumps(self.to_dict())
@classmethod
def from_json(cls, json_str: str) -> ValidationError:
"""Create an instance of ValidationError from a JSON string"""
return cls.from_dict(json.loads(json_str))
def to_dict(self):
"""Returns the dictionary representation of the model using alias"""
_dict = self.dict(by_alias=True,
exclude={
},
exclude_none=True)
# override the default output from pydantic by calling `to_dict()` of each item in loc (list)
_items = []
if self.loc:
for _item in self.loc:
if _item:
_items.append(_item.to_dict())
_dict['loc'] = _items
return _dict
@classmethod
def from_dict(cls, obj: dict) -> ValidationError:
"""Create an instance of ValidationError from a dict"""
if obj is None:
return None
if not isinstance(obj, dict):
return ValidationError.parse_obj(obj)
_obj = ValidationError.parse_obj({
"loc": [ValidationErrorLocInner.from_dict(_item) for _item in obj.get("loc")] if obj.get("loc") is not None else None,
"msg": obj.get("msg"),
"type": obj.get("type")
})
return _obj

138
pkgs/clan-cli/tests/openapi_client/models/validation_error_loc_inner.py Normal file
View File

@@ -0,0 +1,138 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
from __future__ import annotations
from inspect import getfullargspec
import json
import pprint
import re # noqa: F401
from typing import Optional
from pydantic import BaseModel, Field, StrictInt, StrictStr, ValidationError, validator
from typing import Union, Any, List, TYPE_CHECKING
from pydantic import StrictStr, Field
VALIDATIONERRORLOCINNER_ANY_OF_SCHEMAS = ["int", "str"]
class ValidationErrorLocInner(BaseModel):
"""
ValidationErrorLocInner
"""
# data type: str
anyof_schema_1_validator: Optional[StrictStr] = None
# data type: int
anyof_schema_2_validator: Optional[StrictInt] = None
if TYPE_CHECKING:
actual_instance: Union[int, str]
else:
actual_instance: Any
any_of_schemas: List[str] = Field(VALIDATIONERRORLOCINNER_ANY_OF_SCHEMAS, const=True)
class Config:
validate_assignment = True
def __init__(self, *args, **kwargs) -> None:
if args:
if len(args) > 1:
raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`")
if kwargs:
raise ValueError("If a position argument is used, keyword arguments cannot be used.")
super().__init__(actual_instance=args[0])
else:
super().__init__(**kwargs)
@validator('actual_instance')
def actual_instance_must_validate_anyof(cls, v):
instance = ValidationErrorLocInner.construct()
error_messages = []
# validate data type: str
try:
instance.anyof_schema_1_validator = v
return v
except (ValidationError, ValueError) as e:
error_messages.append(str(e))
# validate data type: int
try:
instance.anyof_schema_2_validator = v
return v
except (ValidationError, ValueError) as e:
error_messages.append(str(e))
if error_messages:
# no match
raise ValueError("No match found when setting the actual_instance in ValidationErrorLocInner with anyOf schemas: int, str. Details: " + ", ".join(error_messages))
else:
return v
@classmethod
def from_dict(cls, obj: dict) -> ValidationErrorLocInner:
return cls.from_json(json.dumps(obj))
@classmethod
def from_json(cls, json_str: str) -> ValidationErrorLocInner:
"""Returns the object represented by the json string"""
instance = ValidationErrorLocInner.construct()
error_messages = []
# deserialize data into str
try:
# validation
instance.anyof_schema_1_validator = json.loads(json_str)
# assign value to actual_instance
instance.actual_instance = instance.anyof_schema_1_validator
return instance
except (ValidationError, ValueError) as e:
error_messages.append(str(e))
# deserialize data into int
try:
# validation
instance.anyof_schema_2_validator = json.loads(json_str)
# assign value to actual_instance
instance.actual_instance = instance.anyof_schema_2_validator
return instance
except (ValidationError, ValueError) as e:
error_messages.append(str(e))
if error_messages:
# no match
raise ValueError("No match found when deserializing the JSON string into ValidationErrorLocInner with anyOf schemas: int, str. Details: " + ", ".join(error_messages))
else:
return instance
def to_json(self) -> str:
"""Returns the JSON representation of the actual instance"""
if self.actual_instance is None:
return "null"
to_json = getattr(self.actual_instance, "to_json", None)
if callable(to_json):
return self.actual_instance.to_json()
else:
return json.dumps(self.actual_instance)
def to_dict(self) -> dict:
"""Returns the dict representation of the actual instance"""
if self.actual_instance is None:
return "null"
to_json = getattr(self.actual_instance, "to_json", None)
if callable(to_json):
return self.actual_instance.to_dict()
else:
return json.dumps(self.actual_instance)
def to_str(self) -> str:
"""Returns the string representation of the actual instance"""
return pprint.pformat(self.dict())

303
pkgs/clan-cli/tests/openapi_client/rest.py Normal file
View File

@@ -0,0 +1,303 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import io
import json
import logging
import re
import ssl
from urllib.parse import urlencode, quote_plus
import urllib3
from openapi_client.exceptions import ApiException, UnauthorizedException, ForbiddenException, NotFoundException, ServiceException, ApiValueError, BadRequestException
logger = logging.getLogger(__name__)
class RESTResponse(io.IOBase):
def __init__(self, resp) -> None:
self.urllib3_response = resp
self.status = resp.status
self.reason = resp.reason
self.data = resp.data
def getheaders(self):
"""Returns a dictionary of the response headers."""
return self.urllib3_response.headers
def getheader(self, name, default=None):
"""Returns a given response header."""
return self.urllib3_response.headers.get(name, default)
class RESTClientObject:
def __init__(self, configuration, pools_size=4, maxsize=None) -> None:
# urllib3.PoolManager will pass all kw parameters to connectionpool
# https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/poolmanager.py#L75 # noqa: E501
# https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/connectionpool.py#L680 # noqa: E501
# maxsize is the number of requests to host that are allowed in parallel # noqa: E501
# Custom SSL certificates and client certificates: http://urllib3.readthedocs.io/en/latest/advanced-usage.html # noqa: E501
# cert_reqs
if configuration.verify_ssl:
cert_reqs = ssl.CERT_REQUIRED
else:
cert_reqs = ssl.CERT_NONE
addition_pool_args = {}
if configuration.assert_hostname is not None:
addition_pool_args['assert_hostname'] = configuration.assert_hostname # noqa: E501
if configuration.retries is not None:
addition_pool_args['retries'] = configuration.retries
if configuration.tls_server_name:
addition_pool_args['server_hostname'] = configuration.tls_server_name
if configuration.socket_options is not None:
addition_pool_args['socket_options'] = configuration.socket_options
if maxsize is None:
if configuration.connection_pool_maxsize is not None:
maxsize = configuration.connection_pool_maxsize
else:
maxsize = 4
# https pool manager
if configuration.proxy:
self.pool_manager = urllib3.ProxyManager(
num_pools=pools_size,
maxsize=maxsize,
cert_reqs=cert_reqs,
ca_certs=configuration.ssl_ca_cert,
cert_file=configuration.cert_file,
key_file=configuration.key_file,
proxy_url=configuration.proxy,
proxy_headers=configuration.proxy_headers,
**addition_pool_args
)
else:
self.pool_manager = urllib3.PoolManager(
num_pools=pools_size,
maxsize=maxsize,
cert_reqs=cert_reqs,
ca_certs=configuration.ssl_ca_cert,
cert_file=configuration.cert_file,
key_file=configuration.key_file,
**addition_pool_args
)
def request(self, method, url, query_params=None, headers=None,
body=None, post_params=None, _preload_content=True,
_request_timeout=None):
"""Perform requests.
:param method: http request method
:param url: http request url
:param query_params: query parameters in the url
:param headers: http request headers
:param body: request json body, for `application/json`
:param post_params: request post parameters,
`application/x-www-form-urlencoded`
and `multipart/form-data`
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
"""
method = method.upper()
assert method in ['GET', 'HEAD', 'DELETE', 'POST', 'PUT',
'PATCH', 'OPTIONS']
if post_params and body:
raise ApiValueError(
"body parameter cannot be used with post_params parameter."
)
post_params = post_params or {}
headers = headers or {}
# url already contains the URL query string
# so reset query_params to empty dict
query_params = {}
timeout = None
if _request_timeout:
if isinstance(_request_timeout, (int,float)): # noqa: E501,F821
timeout = urllib3.Timeout(total=_request_timeout)
elif (isinstance(_request_timeout, tuple) and
len(_request_timeout) == 2):
timeout = urllib3.Timeout(
connect=_request_timeout[0], read=_request_timeout[1])
try:
# For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE`
if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']:
# no content type provided or payload is json
if not headers.get('Content-Type') or re.search('json', headers['Content-Type'], re.IGNORECASE):
request_body = None
if body is not None:
request_body = json.dumps(body)
r = self.pool_manager.request(
method, url,
body=request_body,
preload_content=_preload_content,
timeout=timeout,
headers=headers)
elif headers['Content-Type'] == 'application/x-www-form-urlencoded': # noqa: E501
r = self.pool_manager.request(
method, url,
fields=post_params,
encode_multipart=False,
preload_content=_preload_content,
timeout=timeout,
headers=headers)
elif headers['Content-Type'] == 'multipart/form-data':
# must del headers['Content-Type'], or the correct
# Content-Type which generated by urllib3 will be
# overwritten.
del headers['Content-Type']
r = self.pool_manager.request(
method, url,
fields=post_params,
encode_multipart=True,
preload_content=_preload_content,
timeout=timeout,
headers=headers)
# Pass a `string` parameter directly in the body to support
# other content types than Json when `body` argument is
# provided in serialized form
elif isinstance(body, str) or isinstance(body, bytes):
request_body = body
r = self.pool_manager.request(
method, url,
body=request_body,
preload_content=_preload_content,
timeout=timeout,
headers=headers)
else:
# Cannot generate the request from given parameters
msg = """Cannot prepare a request message for provided
arguments. Please check that your arguments match
declared content type."""
raise ApiException(status=0, reason=msg)
# For `GET`, `HEAD`
else:
r = self.pool_manager.request(method, url,
fields={},
preload_content=_preload_content,
timeout=timeout,
headers=headers)
except urllib3.exceptions.SSLError as e:
msg = "{0}\n{1}".format(type(e).__name__, str(e))
raise ApiException(status=0, reason=msg)
if _preload_content:
r = RESTResponse(r)
# log response body
logger.debug("response body: %s", r.data)
if not 200 <= r.status <= 299:
if r.status == 400:
raise BadRequestException(http_resp=r)
if r.status == 401:
raise UnauthorizedException(http_resp=r)
if r.status == 403:
raise ForbiddenException(http_resp=r)
if r.status == 404:
raise NotFoundException(http_resp=r)
if 500 <= r.status <= 599:
raise ServiceException(http_resp=r)
raise ApiException(http_resp=r)
return r
def get_request(self, url, headers=None, query_params=None, _preload_content=True,
_request_timeout=None):
return self.request("GET", url,
headers=headers,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
query_params=query_params)
def head_request(self, url, headers=None, query_params=None, _preload_content=True,
_request_timeout=None):
return self.request("HEAD", url,
headers=headers,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
query_params=query_params)
def options_request(self, url, headers=None, query_params=None, post_params=None,
body=None, _preload_content=True, _request_timeout=None):
return self.request("OPTIONS", url,
headers=headers,
query_params=query_params,
post_params=post_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
body=body)
def delete_request(self, url, headers=None, query_params=None, body=None,
_preload_content=True, _request_timeout=None):
return self.request("DELETE", url,
headers=headers,
query_params=query_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
body=body)
def post_request(self, url, headers=None, query_params=None, post_params=None,
body=None, _preload_content=True, _request_timeout=None):
return self.request("POST", url,
headers=headers,
query_params=query_params,
post_params=post_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
body=body)
def put_request(self, url, headers=None, query_params=None, post_params=None,
body=None, _preload_content=True, _request_timeout=None):
return self.request("PUT", url,
headers=headers,
query_params=query_params,
post_params=post_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
body=body)
def patch_request(self, url, headers=None, query_params=None, post_params=None,
body=None, _preload_content=True, _request_timeout=None):
return self.request("PATCH", url,
headers=headers,
query_params=query_params,
post_params=post_params,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
body=body)

0
pkgs/clan-cli/tests/openapi_client/test/__init__.py Normal file
View File

52
pkgs/clan-cli/tests/openapi_client/test/test_default_api.py Normal file
View File

@@ -0,0 +1,52 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import unittest
from openapi_client.api.default_api import DefaultApi # noqa: E501
class TestDefaultApi(unittest.TestCase):
"""DefaultApi unit test stubs"""
def setUp(self) -> None:
self.api = DefaultApi() # noqa: E501
def tearDown(self) -> None:
pass
def test_get(self) -> None:
"""Test case for get
Get # noqa: E501
"""
pass
def test_health(self) -> None:
"""Test case for health
Health # noqa: E501
"""
pass
def test_root(self) -> None:
"""Test case for root
Root # noqa: E501
"""
pass
if __name__ == '__main__':
unittest.main()

87
pkgs/clan-cli/tests/openapi_client/test/test_entities_api.py Normal file
View File

@@ -0,0 +1,87 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import unittest
from openapi_client.api.entities_api import EntitiesApi # noqa: E501
class TestEntitiesApi(unittest.TestCase):
"""EntitiesApi unit test stubs"""
def setUp(self) -> None:
self.api = EntitiesApi() # noqa: E501
def tearDown(self) -> None:
pass
def test_attach_entity(self) -> None:
"""Test case for attach_entity
Attach Entity # noqa: E501
"""
pass
def test_create_entity(self) -> None:
"""Test case for create_entity
Create Entity # noqa: E501
"""
pass
def test_delete_entity(self) -> None:
"""Test case for delete_entity
Delete Entity # noqa: E501
"""
pass
def test_detach_entity(self) -> None:
"""Test case for detach_entity
Detach Entity # noqa: E501
"""
pass
def test_get_all_entities(self) -> None:
"""Test case for get_all_entities
Get All Entities # noqa: E501
"""
pass
def test_get_attached_entities(self) -> None:
"""Test case for get_attached_entities
Get Attached Entities # noqa: E501
"""
pass
def test_get_entity_by_did(self) -> None:
"""Test case for get_entity_by_did
Get Entity By Did # noqa: E501
"""
pass
def test_get_entity_by_name(self) -> None:
"""Test case for get_entity_by_name
Get Entity By Name # noqa: E501
"""
pass
if __name__ == '__main__':
unittest.main()

63
pkgs/clan-cli/tests/openapi_client/test/test_entity.py Normal file
View File

@@ -0,0 +1,63 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import unittest
import datetime
from openapi_client.models.entity import Entity # noqa: E501
class TestEntity(unittest.TestCase):
"""Entity unit test stubs"""
def setUp(self):
pass
def tearDown(self):
pass
def make_instance(self, include_optional) -> Entity:
"""Test Entity
include_option is a boolean, when False only required
params are included, when True both required and
optional params are included """
# uncomment below to create an instance of `Entity`
"""
model = Entity() # noqa: E501
if include_optional:
return Entity(
did = 'did:sov:test:1234',
name = 'C1',
ip = '127.0.0.1',
visible = True,
other = {network=Carlos Home Network, roles=[service repository, service prosumer]},
attached = True
)
else:
return Entity(
did = 'did:sov:test:1234',
name = 'C1',
ip = '127.0.0.1',
visible = True,
other = {network=Carlos Home Network, roles=[service repository, service prosumer]},
attached = True,
)
"""
def testEntity(self):
"""Test Entity"""
# inst_req_only = self.make_instance(include_optional=False)
# inst_req_and_optional = self.make_instance(include_optional=True)
if __name__ == '__main__':
unittest.main()

61
pkgs/clan-cli/tests/openapi_client/test/test_entity_create.py Normal file
View File

@@ -0,0 +1,61 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import unittest
import datetime
from openapi_client.models.entity_create import EntityCreate # noqa: E501
class TestEntityCreate(unittest.TestCase):
"""EntityCreate unit test stubs"""
def setUp(self):
pass
def tearDown(self):
pass
def make_instance(self, include_optional) -> EntityCreate:
"""Test EntityCreate
include_option is a boolean, when False only required
params are included, when True both required and
optional params are included """
# uncomment below to create an instance of `EntityCreate`
"""
model = EntityCreate() # noqa: E501
if include_optional:
return EntityCreate(
did = 'did:sov:test:1234',
name = 'C1',
ip = '127.0.0.1',
visible = True,
other = {network=Carlos Home Network, roles=[service repository, service prosumer]}
)
else:
return EntityCreate(
did = 'did:sov:test:1234',
name = 'C1',
ip = '127.0.0.1',
visible = True,
other = {network=Carlos Home Network, roles=[service repository, service prosumer]},
)
"""
def testEntityCreate(self):
"""Test EntityCreate"""
# inst_req_only = self.make_instance(include_optional=False)
# inst_req_and_optional = self.make_instance(include_optional=True)
if __name__ == '__main__':
unittest.main()

59
pkgs/clan-cli/tests/openapi_client/test/test_http_validation_error.py Normal file
View File

@@ -0,0 +1,59 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import unittest
import datetime
from openapi_client.models.http_validation_error import HTTPValidationError # noqa: E501
class TestHTTPValidationError(unittest.TestCase):
"""HTTPValidationError unit test stubs"""
def setUp(self):
pass
def tearDown(self):
pass
def make_instance(self, include_optional) -> HTTPValidationError:
"""Test HTTPValidationError
include_option is a boolean, when False only required
params are included, when True both required and
optional params are included """
# uncomment below to create an instance of `HTTPValidationError`
"""
model = HTTPValidationError() # noqa: E501
if include_optional:
return HTTPValidationError(
detail = [
openapi_client.models.validation_error.ValidationError(
loc = [
null
],
msg = '',
type = '', )
]
)
else:
return HTTPValidationError(
)
"""
def testHTTPValidationError(self):
"""Test HTTPValidationError"""
# inst_req_only = self.make_instance(include_optional=False)
# inst_req_and_optional = self.make_instance(include_optional=True)
if __name__ == '__main__':
unittest.main()

55
pkgs/clan-cli/tests/openapi_client/test/test_machine.py Normal file
View File

@@ -0,0 +1,55 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import unittest
import datetime
from openapi_client.models.machine import Machine # noqa: E501
class TestMachine(unittest.TestCase):
"""Machine unit test stubs"""
def setUp(self):
pass
def tearDown(self):
pass
def make_instance(self, include_optional) -> Machine:
"""Test Machine
include_option is a boolean, when False only required
params are included, when True both required and
optional params are included """
# uncomment below to create an instance of `Machine`
"""
model = Machine() # noqa: E501
if include_optional:
return Machine(
name = '',
status = 'online'
)
else:
return Machine(
name = '',
status = 'online',
)
"""
def testMachine(self):
"""Test Machine"""
# inst_req_only = self.make_instance(include_optional=False)
# inst_req_and_optional = self.make_instance(include_optional=True)
if __name__ == '__main__':
unittest.main()

38
pkgs/clan-cli/tests/openapi_client/test/test_repositories_api.py Normal file
View File

@@ -0,0 +1,38 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import unittest
from openapi_client.api.repositories_api import RepositoriesApi # noqa: E501
class TestRepositoriesApi(unittest.TestCase):
"""RepositoriesApi unit test stubs"""
def setUp(self) -> None:
self.api = RepositoriesApi() # noqa: E501
def tearDown(self) -> None:
pass
def test_get_all_repositories(self) -> None:
"""Test case for get_all_repositories
Get All Repositories # noqa: E501
"""
pass
if __name__ == '__main__':
unittest.main()

63
pkgs/clan-cli/tests/openapi_client/test/test_resolution.py Normal file
View File

@@ -0,0 +1,63 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import unittest
import datetime
from openapi_client.models.resolution import Resolution # noqa: E501
class TestResolution(unittest.TestCase):
"""Resolution unit test stubs"""
def setUp(self):
pass
def tearDown(self):
pass
def make_instance(self, include_optional) -> Resolution:
"""Test Resolution
include_option is a boolean, when False only required
params are included, when True both required and
optional params are included """
# uncomment below to create an instance of `Resolution`
"""
model = Resolution() # noqa: E501
if include_optional:
return Resolution(
requester_name = 'C1',
requester_did = 'did:sov:test:1122',
resolved_did = 'did:sov:test:1234',
other = {test=test},
timestamp = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'),
id = 56
)
else:
return Resolution(
requester_name = 'C1',
requester_did = 'did:sov:test:1122',
resolved_did = 'did:sov:test:1234',
other = {test=test},
timestamp = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'),
id = 56,
)
"""
def testResolution(self):
"""Test Resolution"""
# inst_req_only = self.make_instance(include_optional=False)
# inst_req_and_optional = self.make_instance(include_optional=True)
if __name__ == '__main__':
unittest.main()

38
pkgs/clan-cli/tests/openapi_client/test/test_resolution_api.py Normal file
View File

@@ -0,0 +1,38 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import unittest
from openapi_client.api.resolution_api import ResolutionApi # noqa: E501
class TestResolutionApi(unittest.TestCase):
"""ResolutionApi unit test stubs"""
def setUp(self) -> None:
self.api = ResolutionApi() # noqa: E501
def tearDown(self) -> None:
pass
def test_get_all_resolutions(self) -> None:
"""Test case for get_all_resolutions
Get All Resolutions # noqa: E501
"""
pass
if __name__ == '__main__':
unittest.main()

79
pkgs/clan-cli/tests/openapi_client/test/test_service.py Normal file
View File

@@ -0,0 +1,79 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import unittest
import datetime
from openapi_client.models.service import Service # noqa: E501
class TestService(unittest.TestCase):
"""Service unit test stubs"""
def setUp(self):
pass
def tearDown(self):
pass
def make_instance(self, include_optional) -> Service:
"""Test Service
include_option is a boolean, when False only required
params are included, when True both required and
optional params are included """
# uncomment below to create an instance of `Service`
"""
model = Service() # noqa: E501
if include_optional:
return Service(
uuid = '8e285c0c-4e40-430a-a477-26b3b81e30df',
service_name = 'Carlos Printing',
service_type = '3D Printing',
endpoint_url = 'http://127.0.0.1:8000',
status = 'unknown',
other = {action=[register, deregister, delete, create]},
entity_did = 'did:sov:test:1234',
entity = openapi_client.models.entity.Entity(
did = 'did:sov:test:1234',
name = 'C1',
ip = '127.0.0.1',
visible = True,
other = {network=Carlos Home Network, roles=[service repository, service prosumer]},
attached = True, )
)
else:
return Service(
uuid = '8e285c0c-4e40-430a-a477-26b3b81e30df',
service_name = 'Carlos Printing',
service_type = '3D Printing',
endpoint_url = 'http://127.0.0.1:8000',
status = 'unknown',
other = {action=[register, deregister, delete, create]},
entity_did = 'did:sov:test:1234',
entity = openapi_client.models.entity.Entity(
did = 'did:sov:test:1234',
name = 'C1',
ip = '127.0.0.1',
visible = True,
other = {network=Carlos Home Network, roles=[service repository, service prosumer]},
attached = True, ),
)
"""
def testService(self):
"""Test Service"""
# inst_req_only = self.make_instance(include_optional=False)
# inst_req_and_optional = self.make_instance(include_optional=True)
if __name__ == '__main__':
unittest.main()

65
pkgs/clan-cli/tests/openapi_client/test/test_service_create.py Normal file
View File

@@ -0,0 +1,65 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import unittest
import datetime
from openapi_client.models.service_create import ServiceCreate # noqa: E501
class TestServiceCreate(unittest.TestCase):
"""ServiceCreate unit test stubs"""
def setUp(self):
pass
def tearDown(self):
pass
def make_instance(self, include_optional) -> ServiceCreate:
"""Test ServiceCreate
include_option is a boolean, when False only required
params are included, when True both required and
optional params are included """
# uncomment below to create an instance of `ServiceCreate`
"""
model = ServiceCreate() # noqa: E501
if include_optional:
return ServiceCreate(
uuid = '8e285c0c-4e40-430a-a477-26b3b81e30df',
service_name = 'Carlos Printing',
service_type = '3D Printing',
endpoint_url = 'http://127.0.0.1:8000',
status = 'unknown',
other = {action=[register, deregister, delete, create]},
entity_did = 'did:sov:test:1234'
)
else:
return ServiceCreate(
uuid = '8e285c0c-4e40-430a-a477-26b3b81e30df',
service_name = 'Carlos Printing',
service_type = '3D Printing',
endpoint_url = 'http://127.0.0.1:8000',
status = 'unknown',
other = {action=[register, deregister, delete, create]},
entity_did = 'did:sov:test:1234',
)
"""
def testServiceCreate(self):
"""Test ServiceCreate"""
# inst_req_only = self.make_instance(include_optional=False)
# inst_req_and_optional = self.make_instance(include_optional=True)
if __name__ == '__main__':
unittest.main()

66
pkgs/clan-cli/tests/openapi_client/test/test_services_api.py Normal file
View File

@@ -0,0 +1,66 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import unittest
from openapi_client.api.services_api import ServicesApi # noqa: E501
class TestServicesApi(unittest.TestCase):
"""ServicesApi unit test stubs"""
def setUp(self) -> None:
self.api = ServicesApi() # noqa: E501
def tearDown(self) -> None:
pass
def test_create_service(self) -> None:
"""Test case for create_service
Create Service # noqa: E501
"""
pass
def test_delete_service(self) -> None:
"""Test case for delete_service
Delete Service # noqa: E501
"""
pass
def test_get_all_services(self) -> None:
"""Test case for get_all_services
Get All Services # noqa: E501
"""
pass
def test_get_service_by_did(self) -> None:
"""Test case for get_service_by_did
Get Service By Did # noqa: E501
"""
pass
def test_get_services_by_name(self) -> None:
"""Test case for get_services_by_name
Get Services By Name # noqa: E501
"""
pass
if __name__ == '__main__':
unittest.main()

99
pkgs/clan-cli/tests/openapi_client/test/test_services_by_name.py Normal file
View File

@@ -0,0 +1,99 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import unittest
import datetime
from openapi_client.models.services_by_name import ServicesByName # noqa: E501
class TestServicesByName(unittest.TestCase):
"""ServicesByName unit test stubs"""
def setUp(self):
pass
def tearDown(self):
pass
def make_instance(self, include_optional) -> ServicesByName:
"""Test ServicesByName
include_option is a boolean, when False only required
params are included, when True both required and
optional params are included """
# uncomment below to create an instance of `ServicesByName`
"""
model = ServicesByName() # noqa: E501
if include_optional:
return ServicesByName(
entity = openapi_client.models.entity.Entity(
did = 'did:sov:test:1234',
name = 'C1',
ip = '127.0.0.1',
visible = True,
other = {network=Carlos Home Network, roles=[service repository, service prosumer]},
attached = True, ),
services = [
openapi_client.models.service.Service(
uuid = '8e285c0c-4e40-430a-a477-26b3b81e30df',
service_name = 'Carlos Printing',
service_type = '3D Printing',
endpoint_url = 'http://127.0.0.1:8000',
status = 'unknown',
other = {action=[register, deregister, delete, create]},
entity_did = 'did:sov:test:1234',
entity = openapi_client.models.entity.Entity(
did = 'did:sov:test:1234',
name = 'C1',
ip = '127.0.0.1',
visible = True,
other = {network=Carlos Home Network, roles=[service repository, service prosumer]},
attached = True, ), )
]
)
else:
return ServicesByName(
entity = openapi_client.models.entity.Entity(
did = 'did:sov:test:1234',
name = 'C1',
ip = '127.0.0.1',
visible = True,
other = {network=Carlos Home Network, roles=[service repository, service prosumer]},
attached = True, ),
services = [
openapi_client.models.service.Service(
uuid = '8e285c0c-4e40-430a-a477-26b3b81e30df',
service_name = 'Carlos Printing',
service_type = '3D Printing',
endpoint_url = 'http://127.0.0.1:8000',
status = 'unknown',
other = {action=[register, deregister, delete, create]},
entity_did = 'did:sov:test:1234',
entity = openapi_client.models.entity.Entity(
did = 'did:sov:test:1234',
name = 'C1',
ip = '127.0.0.1',
visible = True,
other = {network=Carlos Home Network, roles=[service repository, service prosumer]},
attached = True, ), )
],
)
"""
def testServicesByName(self):
"""Test ServicesByName"""
# inst_req_only = self.make_instance(include_optional=False)
# inst_req_and_optional = self.make_instance(include_optional=True)
if __name__ == '__main__':
unittest.main()

34
pkgs/clan-cli/tests/openapi_client/test/test_status.py Normal file
View File

@@ -0,0 +1,34 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import unittest
import datetime
from openapi_client.models.status import Status # noqa: E501
class TestStatus(unittest.TestCase):
"""Status unit test stubs"""
def setUp(self):
pass
def tearDown(self):
pass
def testStatus(self):
"""Test Status"""
# inst = Status()
if __name__ == '__main__':
unittest.main()

61
pkgs/clan-cli/tests/openapi_client/test/test_validation_error.py Normal file
View File

@@ -0,0 +1,61 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import unittest
import datetime
from openapi_client.models.validation_error import ValidationError # noqa: E501
class TestValidationError(unittest.TestCase):
"""ValidationError unit test stubs"""
def setUp(self):
pass
def tearDown(self):
pass
def make_instance(self, include_optional) -> ValidationError:
"""Test ValidationError
include_option is a boolean, when False only required
params are included, when True both required and
optional params are included """
# uncomment below to create an instance of `ValidationError`
"""
model = ValidationError() # noqa: E501
if include_optional:
return ValidationError(
loc = [
null
],
msg = '',
type = ''
)
else:
return ValidationError(
loc = [
null
],
msg = '',
type = '',
)
"""
def testValidationError(self):
"""Test ValidationError"""
# inst_req_only = self.make_instance(include_optional=False)
# inst_req_and_optional = self.make_instance(include_optional=True)
if __name__ == '__main__':
unittest.main()

51
pkgs/clan-cli/tests/openapi_client/test/test_validation_error_loc_inner.py Normal file
View File

@@ -0,0 +1,51 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import unittest
import datetime
from openapi_client.models.validation_error_loc_inner import ValidationErrorLocInner # noqa: E501
class TestValidationErrorLocInner(unittest.TestCase):
"""ValidationErrorLocInner unit test stubs"""
def setUp(self):
pass
def tearDown(self):
pass
def make_instance(self, include_optional) -> ValidationErrorLocInner:
"""Test ValidationErrorLocInner
include_option is a boolean, when False only required
params are included, when True both required and
optional params are included """
# uncomment below to create an instance of `ValidationErrorLocInner`
"""
model = ValidationErrorLocInner() # noqa: E501
if include_optional:
return ValidationErrorLocInner(
)
else:
return ValidationErrorLocInner(
)
"""
def testValidationErrorLocInner(self):
"""Test ValidationErrorLocInner"""
# inst_req_only = self.make_instance(include_optional=False)
# inst_req_and_optional = self.make_instance(include_optional=True)
if __name__ == '__main__':
unittest.main()

389
pkgs/clan-cli/tests/test_db_api.py
View File

@@ -1,337 +1,78 @@
import urllib.parse as url
from typing import Any
import random
import uuid
from api import TestClient
from openapi_client import ApiClient
from openapi_client.api import DefaultApi
from openapi_client.api.entities_api import EntitiesApi
from openapi_client.api.services_api import ServicesApi
from openapi_client.models import (
Entity,
EntityCreate,
Machine,
ServiceCreate,
Status,
)
default_entity_did_url = "entity_did=did%3Asov%3Atest%3A1234"
default_entity_did = "did:sov:test:1234"
default_entity_did2 = "did:sov:test:1235"
default_entity_did3 = "did:sov:test:1236"
default_entity_did4 = "did:sov:test:1237"
default_entity_did5 = "did:sov:test:1238"
random.seed(42)
def assert_extra_info(
infos: list[str],
request_body: dict[str, Any],
response: dict[str, str],
) -> None:
# print(type())
for info in infos:
assert info in response.keys()
# TODO maybe check the content of the extra info ...
response.pop(info)
assert response == request_body
num_uuids = 100
uuids = [str(uuid.UUID(int=random.getrandbits(128))) for i in range(num_uuids)]
def make_test_post_and_get(
api: TestClient,
request_body: dict[str, Any],
paramter: str,
get_request: str = default_entity_did_url,
apiversion: str = "v1",
) -> None:
# test post
response = api.post(
f"/api/{apiversion}/create_{paramter}",
json=request_body,
headers={"Content-Type": "application/json"},
def test_health(api_client: ApiClient) -> None:
default = DefaultApi(api_client=api_client)
res: Machine = default.health()
assert res.status == Status.ONLINE
def test_entities_empty(api_client: ApiClient) -> None:
entity = EntitiesApi(api_client=api_client)
res = entity.get_all_entities()
assert res == []
def create_entities(num: int = 10) -> list[EntityCreate]:
res = []
for i in range(num):
en = EntityCreate(
did=f"did:sov:test:12{i}",
name=f"C{i}",
ip=f"127.0.0.1:{7000+i}",
visible=True,
other={},
)
assert response.status_code == 200
res.append(en)
return res
if paramter == "repository":
assert_extra_info(["time_created"], request_body, response.json())
elif paramter == "resolution":
assert_extra_info(["timestamp", "id"], request_body, response.json())
elif paramter == "consumer":
assert_extra_info(["id"], request_body, response.json())
elif paramter == "entity":
assert_extra_info(
["consumers", "producers", "repository"], request_body, response.json()
def create_service(idx: int, entity: Entity) -> ServiceCreate:
se = ServiceCreate(
uuid=uuids[idx],
service_name=f"Carlos Printing{idx}",
service_type="3D Printing",
endpoint_url=f"{entity.ip}/v1/print_daemon{idx}",
status="unknown",
other={"action": ["register", "deregister", "delete", "create"]},
entity_did=entity.did,
)
else:
assert response.json() == request_body
# test get
response = api.get(
f"api/{apiversion}/get_{paramter}?{get_request}&skip=0&limit=100"
)
assert response.status_code == 200
if paramter == "repository":
assert_extra_info(["time_created"], request_body, response.json()[0])
elif paramter == "resolution":
assert_extra_info(["timestamp", "id"], request_body, response.json()[0])
elif paramter == "consumer":
assert_extra_info(["id"], request_body, response.json()[0])
elif paramter == "entity":
assert_extra_info(
["consumers", "producers", "repository"], request_body, response.json()
)
else:
assert response.json() == [request_body]
return se
#########################
# #
# Producer #
# #
#########################
def test_producer(api: TestClient) -> None:
request_body = {
"uuid": "8e285c0c-4e40-430a-a477-26b3b81e30df",
"service_name": "Carlo'''s Printing",
"service_type": "3D Printing",
"endpoint_url": "http://127.0.0.1:8000",
"status": "unknown",
"other": {"action": ["register", "deregister", "delete", "create"]},
"entity_did": default_entity_did,
}
paramter = "producer"
# get_request = "entity_did=did%3Asov%3Atest%3A1234"
make_test_post_and_get(api, request_body, paramter)
def test_create_entities(api_client: ApiClient) -> None:
api = EntitiesApi(api_client=api_client)
for own_entity in create_entities():
res: Entity = api.create_entity(own_entity)
assert res.did == own_entity.did
assert res.attached is False
def test_producer2(api: TestClient) -> None:
request_body = {
"uuid": "8e285c0c-4e40-430a-a477-26b3b81e30d1",
"service_name": "Luis'''s Fax",
"service_type": "Fax",
"endpoint_url": "http://127.0.0.1:8001",
"status": "unknown",
"other": {"action": ["register", "deregister", "delete", "create"]},
"entity_did": default_entity_did2,
}
paramter = "producer"
get_request = "entity_did=" + url.quote(default_entity_did2)
make_test_post_and_get(api, request_body, paramter, get_request)
def test_producer3(api: TestClient) -> None:
request_body = {
"uuid": "8e285c0c-4e40-430a-a477-26b3b81e30d2",
"service_name": "Erdem'''s VR-Stream",
"service_type": "VR-Stream",
"endpoint_url": "http://127.0.0.1:8002",
"status": "unknown",
"other": {"action": ["register", "deregister", "delete", "create"]},
"entity_did": default_entity_did3,
}
paramter = "producer"
get_request = "entity_did=" + url.quote(default_entity_did3)
make_test_post_and_get(api, request_body, paramter, get_request)
def test_producer4(api: TestClient) -> None:
request_body = {
"uuid": "8e285c0c-4e40-430a-a477-26b3b81e30d3",
"service_name": "Onur'''s gallary",
"service_type": "gallary",
"endpoint_url": "http://127.0.0.1:8003",
"status": "unknown",
"other": {"action": ["register", "deregister", "delete", "create"]},
"entity_did": default_entity_did4,
}
paramter = "producer"
get_request = "entity_did=" + url.quote(default_entity_did4)
make_test_post_and_get(api, request_body, paramter, get_request)
def test_producer5(api: TestClient) -> None:
request_body = {
"uuid": "8e285c0c-4e40-430a-a477-26b3b81e30d4",
"service_name": "Sara'''s Game-Shop",
"service_type": "Game-Shop",
"endpoint_url": "http://127.0.0.1:8004",
"status": "unknown",
"other": {"action": ["register", "deregister", "delete", "create"]},
"entity_did": default_entity_did5,
}
paramter = "producer"
get_request = "entity_did=" + url.quote(default_entity_did5)
make_test_post_and_get(api, request_body, paramter, get_request)
#########################
# #
# Consumer #
# #
#########################
def test_consumer(api: TestClient) -> None:
request_body = {
"entity_did": default_entity_did,
"producer_uuid": "8e285c0c-4e40-430a-a477-26b3b81e30df",
"other": {"test": "test"},
}
paramter = "consumer"
# get_request = "entity_did=did%3Asov%3Atest%3A1234"
make_test_post_and_get(api, request_body, paramter)
def test_consumer2(api: TestClient) -> None:
request_body = {
"entity_did": default_entity_did2,
"producer_uuid": "8e285c0c-4e40-430a-a477-26b3b81e30d4",
"other": {"war": "games"},
}
paramter = "consumer"
get_request = "entity_did=" + url.quote(default_entity_did2)
make_test_post_and_get(api, request_body, paramter, get_request)
#########################
# #
# REPOSITORY #
# #
#########################
def test_repository(api: TestClient) -> None:
request_body = {
"uuid": "8e285c0c-4e40-430a-a477-26b3b81e30df",
"service_name": "Carlo'''s Printing",
"service_type": "3D Printing",
"endpoint_url": "http://127.0.0.1:8000",
"status": "unknown",
"other": {"test": "test"},
"entity_did": default_entity_did,
}
paramter = "repository"
# get_request = "entity_did=did%3Asov%3Atest%3A1234"
make_test_post_and_get(api, request_body, paramter)
def test_repository2(api: TestClient) -> None:
request_body = {
"uuid": "8e285c0c-4e40-430a-a477-26b3b81e30d1",
"service_name": "Luis'''s Fax",
"service_type": "Fax",
"endpoint_url": "http://127.0.0.1:8001",
"status": "unknown",
"other": {"faxen": "dicke"},
"entity_did": default_entity_did2,
}
paramter = "repository"
get_request = "entity_did=" + url.quote(default_entity_did2)
make_test_post_and_get(api, request_body, paramter, get_request)
def test_repository3(api: TestClient) -> None:
request_body = {
"uuid": "8e285c0c-4e40-430a-a477-26b3b81e30d2",
"service_name": "Erdem'''s VR-Stream",
"service_type": "VR-Stream",
"endpoint_url": "http://127.0.0.1:8002",
"status": "unknown",
"other": {"oculos": "rift"},
"entity_did": default_entity_did3,
}
paramter = "repository"
get_request = "entity_did=" + url.quote(default_entity_did3)
make_test_post_and_get(api, request_body, paramter, get_request)
def test_repository4(api: TestClient) -> None:
request_body = {
"uuid": "8e285c0c-4e40-430a-a477-26b3b81e30d3",
"service_name": "Onur'''s gallary",
"service_type": "gallary",
"endpoint_url": "http://127.0.0.1:8003",
"status": "unknown",
"other": {"nice": "pics"},
"entity_did": default_entity_did4,
}
paramter = "repository"
get_request = "entity_did=" + url.quote(default_entity_did4)
make_test_post_and_get(api, request_body, paramter, get_request)
def test_repository5(api: TestClient) -> None:
request_body = {
"uuid": "8e285c0c-4e40-430a-a477-26b3b81e30d4",
"service_name": "Sara'''s Game-Shop",
"service_type": "Game-Shop",
"endpoint_url": "http://127.0.0.2:8004",
"status": "unknown",
"other": {"war": "games"},
"entity_did": default_entity_did5,
}
paramter = "repository"
get_request = "entity_did=" + url.quote(default_entity_did5)
make_test_post_and_get(api, request_body, paramter, get_request)
#########################
# #
# Entity #
# #
#########################
def test_entity(api: TestClient) -> None:
request_body = {
"did": default_entity_did,
"name": "C1",
"ip": "127.0.0.1:5555",
"attached": False,
"visible": True,
"other": {
"network": "Carlo1's Home Network",
"roles": ["service repository", "service consumer"],
},
}
paramter = "entity"
# get_request = "entity_did=did%3Asov%3Atest%3A1234"
make_test_post_and_get(api, request_body, paramter)
def test_entity2(api: TestClient) -> None:
request_body = {
"did": default_entity_did2,
"name": "C2",
"ip": "127.0.0.1:5555",
"attached": False,
"visible": True,
"other": {
"network": "Carlo2's Home Network",
"roles": ["service repository", "service prosumer"],
},
}
paramter = "entity"
get_request = "entity_did=" + url.quote(default_entity_did2)
make_test_post_and_get(api, request_body, paramter, get_request)
#########################
# #
# Resolution #
# #
#########################
def test_resolution(api: TestClient) -> None:
request_body = {
"requester_did": default_entity_did2,
"requester_name": "C2",
"resolved_did": default_entity_did,
"other": {"test": "test"},
}
paramter = "resolution"
get_request = "requester_did=" + url.quote(default_entity_did2)
make_test_post_and_get(api, request_body, paramter, get_request)
def test_resolution2(api: TestClient) -> None:
request_body = {
"requester_did": default_entity_did3,
"requester_name": "C3",
"resolved_did": default_entity_did,
"other": {"test": "test"},
}
paramter = "resolution"
get_request = "requester_did=" + url.quote(default_entity_did3)
make_test_post_and_get(api, request_body, paramter, get_request)
def test_resolution3(api: TestClient) -> None:
request_body = {
"requester_did": default_entity_did4,
"requester_name": "C4",
"resolved_did": default_entity_did,
"other": {"test": "test"},
}
paramter = "resolution"
get_request = "requester_did=" + url.quote(default_entity_did4)
make_test_post_and_get(api, request_body, paramter, get_request)
def test_create_services(api_client: ApiClient) -> None:
sapi = ServicesApi(api_client=api_client)
eapi = EntitiesApi(api_client=api_client)
for midx, entity in enumerate(eapi.get_all_entities()):
for idx in range(4):
service_obj = create_service(idx + 4 * midx, entity)
service = sapi.create_service(service_obj)
assert service.uuid == service_obj.uuid

2
pkgs/ui/README.md
View File

@@ -25,3 +25,5 @@ Than run this command:
```
GITEA_TOKEN=<YOUR_TOKEN> nix run .#update-ui-assets
```
.

2
pkgs/ui/nix/ui-assets.nix
View File

@@ -1,5 +1,5 @@
{ fetchzip }:
fetchzip {
url = "https://gitea.gchq.icu/api/packages/IoSL/generic/IoSL-service-aware-frontend/15d2rn12jhrwry2ipvjhn62dgl7vvdrkc1zkp02xfvaz8ijf18s8/assets.tar.gz";
sha256 = "15d2rn12jhrwry2ipvjhn62dgl7vvdrkc1zkp02xfvaz8ijf18s8";
sha256 = "sha256-SKPgZERfbdcFuPMHNnPb+9DXhLFQ7huFzzxDKYLNopU=";
}

6
pkgs/ui/src/app/access-point/page.tsx
View File

@@ -2,7 +2,7 @@
import { mutate } from "swr";
import { useGetAttachedEntities } from "@/api/entities/entities";
import { useGetRepositories } from "@/api/repositories/repositories";
import { useGetAllRepositories } from "@/api/repositories/repositories";
import SummaryDetails from "@/components/summary_card";
import CustomTable from "@/components/table";
import {
@@ -22,7 +22,7 @@ export default function AccessPoint() {
data: APRepositories,
isLoading: laodingRepositories,
swrKey: repositoriesKeyFunc,
} = useGetRepositories();
} = useGetAllRepositories();
const onRefresh = () => {
const attachedEntitiesKey =
@@ -65,6 +65,7 @@ export default function AccessPoint() {
loading={loadingAttachements}
data={APAttachementData?.data}
configuration={APAttachmentsTableConfig}
tkey="attachment-table"
/>
</div>
<div>
@@ -73,6 +74,7 @@ export default function AccessPoint() {
loading={laodingRepositories}
data={APRepositories?.data}
configuration={APServiceRepositoryTableConfig}
tkey="service-repository-table"
/>
</div>
</div>

168
pkgs/ui/src/app/client-1/page.tsx
View File

@@ -1,168 +0,0 @@
"use client";
import { useEffect, useRef, useState } from "react";
import {
Client1ConsumerTableConfig,
Client1ProducerTableConfig,
} from "@/config/client_1";
import CustomTable from "@/components/table";
import useGetEntityByName from "@/components/hooks/useGetEntityById";
import {
Alert,
Button,
Card,
CardContent,
CardHeader,
Skeleton,
Snackbar,
Typography,
} from "@mui/material";
import CopyToClipboard from "@/components/copy_to_clipboard";
import { mutate } from "swr";
import { useGetEntity } from "@/api/entities/entities";
import { BASE_URL } from "@/constants";
import axios from "axios";
export default function Client1() {
const { entity } = useGetEntityByName("C1");
const {
data: client1,
isLoading,
swrKey: entityKeyFunc,
} = useGetEntity({ entity_did: entity?.did });
const cardContentRef = useRef(null);
const [isAttached, setIsAttached] = useState(entity?.attached || false);
const [snackbarOpen, setSnackbarOpen] = useState(false);
const [snackbarMessage, setSnackbarMessage] = useState("");
const closeSnackBar = () => {
setSnackbarMessage("");
setSnackbarOpen(false);
};
const onAttachEntity = async () => {
try {
const response = await axios.post(`${BASE_URL}/attach`, {
entity_did: entity?.did,
});
setSnackbarMessage(response.data.message);
setSnackbarOpen(true);
} catch (error) {
console.error(error);
} finally {
setIsAttached(true);
}
};
const onDetachEntity = async () => {
try {
const response = await axios.post(`${BASE_URL}/detach`, {
entity_did: entity?.did,
});
console.log(response);
setSnackbarMessage("Entity detached successfully.");
setSnackbarOpen(true);
} catch (error) {
console.error(error);
} finally {
setIsAttached(false);
}
};
const onRefresh = () => {
const entityKey =
typeof entityKeyFunc === "function" ? entityKeyFunc() : entityKeyFunc;
if (entityKey) mutate(entityKey);
};
useEffect(() => {
const interval = setInterval(() => {
onRefresh();
}, 1000);
return () => clearInterval(interval);
// eslint-disable-next-line react-hooks/exhaustive-deps
}, []);
if (isLoading) return <Skeleton height={500} />;
return (
<div className="m-10">
<div
style={{
display: "flex",
alignItems: "center",
justifyContent: "space-between",
}}
>
<h2>Client 1</h2>
<div>
{isAttached === false ? (
<Button
onClick={onAttachEntity}
className="mr-6"
variant="contained"
>
Attach
</Button>
) : (
<Button
onClick={onDetachEntity}
className="mr-6"
variant="contained"
>
Detach
</Button>
)}
<Button onClick={onRefresh} variant="contained">
Refresh
</Button>
</div>
</div>
<Card variant="outlined">
<CardHeader
subheader="Summary"
action={<CopyToClipboard contentRef={cardContentRef} />}
/>
<CardContent ref={cardContentRef}>
<Typography color="text.primary" gutterBottom>
DID: <code>{client1?.data?.did}</code>
</Typography>
<Typography color="text.primary" gutterBottom>
IP: <code>{client1?.data?.ip}</code>
</Typography>
<Typography color="text.primary" gutterBottom>
Network: <code>{client1?.data?.other?.network}</code>
</Typography>
</CardContent>
</Card>
<div>
<h4>Consumer View</h4>
<CustomTable
loading={isLoading}
data={client1?.data?.producers}
configuration={Client1ConsumerTableConfig}
/>
</div>
<div>
<h4>Producer View</h4>
<CustomTable
loading={isLoading}
data={client1?.data?.producers}
configuration={Client1ProducerTableConfig}
/>
</div>
<Snackbar
onClose={closeSnackBar}
anchorOrigin={{ vertical: "top", horizontal: "center" }}
open={snackbarOpen}
autoHideDuration={1000}
>
<Alert severity="success" sx={{ width: "100%" }}>
{snackbarMessage}
</Alert>
</Snackbar>
</div>
);
}

150
pkgs/ui/src/app/client-2/page.tsx → pkgs/ui/src/app/client/[client_name]/page.tsx
View File

@@ -1,70 +1,47 @@
"use client";
import { useEffect, useRef, useState } from "react";
import {
Client2ConsumerTableConfig,
Client2ProducerTableConfig,
} from "@/config/client_2";
import { useEffect, useMemo, useRef, useState } from "react";
import { ClientTableConfig, ServiceTableConfig } from "@/config/client_1";
import CustomTable from "@/components/table";
import useGetEntityByName from "@/components/hooks/useGetEntityById";
import {
Alert,
Button,
Card,
CardContent,
CardHeader,
Skeleton,
Typography,
Snackbar,
Alert,
Typography,
} from "@mui/material";
import CopyToClipboard from "@/components/copy_to_clipboard";
import { useGetEntity } from "@/api/entities/entities";
import { useGetServicesByName } from "@/api/services/services";
import { attachEntity, detachEntity } from "@/api/entities/entities";
import { mutate } from "swr";
import axios from "axios";
import { BASE_URL } from "@/constants";
import { Skeleton } from "@mui/material";
import { Service } from "@/api/model";
export default function Client({
params,
}: {
params: { client_name: string };
}) {
const { client_name } = params;
export default function Client2() {
const { entity } = useGetEntityByName("C2");
const {
data: client2,
isLoading,
data: services,
isLoading: services_loading,
swrKey: entityKeyFunc,
} = useGetEntity({ entity_did: entity?.did });
const cardContentRef = useRef(null);
const [isAttached, setIsAttached] = useState(entity?.attached);
const [snackbarOpen, setSnackbarOpen] = useState(false);
const [snackbarMessage, setSnackbarMessage] = useState("");
const closeSnackBar = () => {
setSnackbarMessage("");
setSnackbarOpen(false);
};
const onAttachEntity = async () => {
try {
const response = await axios.post(`${BASE_URL}/attach`, {
entity_did: entity?.did,
} = useGetServicesByName({
entity_name: client_name,
});
alert(response.data.message);
} catch (error) {
console.error(error);
} finally {
setIsAttached(true);
}
};
const onDetachEntity = async () => {
try {
const response = await axios.post(`${BASE_URL}/detach`, {
entity_did: entity?.did,
const entity = services?.data?.entity;
const clients: Service[] = useMemo(() => {
if (services?.data?.services) {
return services.data.services.filter((service) => {
if (service.entity_did !== entity?.did) return true;
});
console.log("detach", response);
alert("Entity Detached Successfully.");
} catch (error) {
console.error(error);
} finally {
setIsAttached(false);
}
};
return [];
}, [services, entity?.did]);
const onRefresh = () => {
const entityKey =
@@ -75,13 +52,57 @@ export default function Client2() {
useEffect(() => {
const interval = setInterval(() => {
onRefresh();
}, 1000);
}, 5000);
return () => clearInterval(interval);
// eslint-disable-next-line react-hooks/exhaustive-deps
}, []);
if (isLoading) return <Skeleton height={500} />;
const cardContentRef = useRef(null);
const [snackbarOpen, setSnackbarOpen] = useState(false);
const [snackbarMessage, setSnackbarMessage] = useState("");
const [isAttached, setIsAttached] = useState(entity?.attached);
const closeSnackBar = () => {
setSnackbarMessage("");
setSnackbarOpen(false);
};
const onAttachEntity = async () => {
try {
if (entity) {
const response = await attachEntity(entity.did);
setSnackbarMessage(response.data.message);
setSnackbarOpen(true);
} else {
console.error("no entity");
}
} catch (error) {
console.error(error);
} finally {
setIsAttached(true);
}
};
const onDetachEntity = async () => {
try {
if (entity) {
const response = await detachEntity(entity.did);
console.log(response);
setSnackbarMessage("Entity detached successfully.");
setSnackbarOpen(true);
} else {
console.error("no entity");
}
} catch (error) {
console.error(error);
} finally {
setIsAttached(false);
}
};
if (services_loading) return <Skeleton height={500} />;
if (!services) return <Alert severity="error">Client not found</Alert>;
return (
<div className="m-10">
@@ -92,7 +113,7 @@ export default function Client2() {
justifyContent: "space-between",
}}
>
<h2>Client 2</h2>
<h2>Client 1</h2>
<div>
{isAttached === false ? (
<Button
@@ -111,6 +132,7 @@ export default function Client2() {
Detach
</Button>
)}
<Button onClick={onRefresh} variant="contained">
Refresh
</Button>
@@ -124,30 +146,32 @@ export default function Client2() {
/>
<CardContent ref={cardContentRef}>
<Typography color="text.primary" gutterBottom>
DID: <code>{client2?.data?.did}</code>
DID: <code>{entity?.did}</code>
</Typography>
<Typography color="text.primary" gutterBottom>
IP: <code>{client2?.data?.ip}</code>
IP: <code>{entity?.ip}</code>
</Typography>
<Typography color="text.primary" gutterBottom>
Network: <code>{client2?.data?.other?.network}</code>
Network: <code>{entity?.other?.network}</code>
</Typography>
</CardContent>
</Card>
<div>
<h4>Consumer View</h4>
<h4>Client View</h4>
<CustomTable
loading={isLoading}
data={client2?.data?.producers}
configuration={Client2ConsumerTableConfig}
loading={services_loading}
data={clients}
configuration={ClientTableConfig}
tkey="client-table"
/>
</div>
<div>
<h4>Producer View</h4>
<h4>Service View</h4>
<CustomTable
loading={isLoading}
data={client2?.data?.producers}
configuration={Client2ProducerTableConfig}
loading={services_loading}
data={services?.data?.services}
configuration={ServiceTableConfig}
tkey="service-table"
/>
</div>
<Snackbar

1
pkgs/ui/src/app/distributed-ledger-gateway/page.tsx
View File

@@ -43,6 +43,7 @@ export default function DLG() {
loading={loadingResolutions}
data={resolutionData}
configuration={DLGResolutionTableConfig}
tkey="resolution_table"
/>
</div>
</div>

3
pkgs/ui/src/app/home/page.tsx
View File

@@ -24,7 +24,7 @@ export default function Home() {
useEffect(() => {
const interval = setInterval(() => {
onRefresh();
}, 500);
}, 5000);
return () => clearInterval(interval);
// eslint-disable-next-line react-hooks/exhaustive-deps
@@ -45,6 +45,7 @@ export default function Home() {
loading={data.loadingEntities}
data={data?.allEntities}
configuration={HomeTableConfig}
tkey="home_table"
/>
</div>

4
pkgs/ui/src/components/hooks/useAppContext.tsx
View File

@@ -1,4 +1,4 @@
import { useGetEntities } from "@/api/entities/entities";
import { useGetAllEntities } from "@/api/entities/entities";
import { Entity } from "@/api/model";
import { AxiosError } from "axios";
import React, {
@@ -33,7 +33,7 @@ interface AppContextProviderProps {
export const WithAppState = (props: AppContextProviderProps) => {
const { children } = props;
const { data: entityData, swrKey: entitiesKeyFunc } = useGetEntities();
const { data: entityData, swrKey: entitiesKeyFunc } = useGetAllEntities();
const isLoading = false;
const error = undefined;

4
pkgs/ui/src/components/sidebar/index.tsx
View File

@@ -35,13 +35,13 @@ const menuEntityEntries: MenuEntry[] = [
{
icon: <PersonIcon />,
label: "C1",
to: "/client-1",
to: "/client/C1",
disabled: false,
},
{
icon: <PersonIcon />,
label: "C2",
to: "/client-2",
to: "/client/C2",
disabled: false,
},
];

17
pkgs/ui/src/components/table/index.tsx
View File

@@ -11,7 +11,7 @@ import { StyledTableCell, StyledTableRow } from "./style";
import { ICustomTable, CustomTableConfiguration } from "@/types";
import { Checkbox, Skeleton } from "@mui/material";
const CustomTable = ({ configuration, data, loading }: ICustomTable) => {
const CustomTable = ({ configuration, data, loading, tkey }: ICustomTable) => {
if (loading)
return <Skeleton variant="rectangular" animation="wave" height={200} />;
@@ -36,6 +36,7 @@ const CustomTable = ({ configuration, data, loading }: ICustomTable) => {
// cover use case if we want to render a component
if (render) renderedValue = render(value);
console.log("renderTableCell key", cellKey);
return (
<StyledTableCell key={cellKey} align="left">
{renderedValue}
@@ -56,12 +57,18 @@ const CustomTable = ({ configuration, data, loading }: ICustomTable) => {
<TableBody>
{data.map((data: any, rowIndex: number) => (
<StyledTableRow key={rowIndex}>
{configuration.map((column: CustomTableConfiguration) => {
{configuration.map(
(column: CustomTableConfiguration, columnIndex: number) => {
const cellValue: any = data[column.key];
const cellKey = column.key;
const cellKey = tkey + ":" + column.key + ":" + rowIndex;
const renderComponent = column?.render;
return renderTableCell(cellValue, cellKey, renderComponent);
})}
return renderTableCell(
cellValue,
cellKey + ":" + columnIndex,
renderComponent,
);
},
)}
</StyledTableRow>
))}
</TableBody>

5
pkgs/ui/src/config/client_1/index.tsx
View File

@@ -1,6 +1,6 @@
import { Button } from "@mui/material";
export const Client1ConsumerTableConfig = [
export const ClientTableConfig = [
{
key: "service_name",
label: "Service name",
@@ -34,7 +34,7 @@ export const Client1ConsumerTableConfig = [
// },
];
export const Client1ProducerTableConfig = [
export const ServiceTableConfig = [
{
key: "service_name",
label: "Service name",
@@ -71,6 +71,7 @@ export const Client1ProducerTableConfig = [
))}
</>
);
console.log("render", renderedValue);
return renderedValue;
},
},

4
pkgs/ui/src/config/home/index.ts
View File

@@ -8,7 +8,7 @@ export const HomeTableConfig = [
label: "Entity DID",
},
{
key: "other",
key: "network",
label: "Network",
render: (value: any) => {
const renderedValue = typeof value === "object" ? value?.network : "-";
@@ -20,7 +20,7 @@ export const HomeTableConfig = [
label: "IP address",
},
{
key: "other",
key: "roles",
label: "Roles",
render: (value: any) => {
const renderedValue =

1
pkgs/ui/src/types/index.ts
View File

@@ -8,6 +8,7 @@ export interface ICustomTable {
configuration: CustomTableConfiguration[];
data: any;
loading?: boolean;
tkey: string;
}
export interface EntityDetails {