pycivil 0.1.0__tar.gz

pycivil-0.1.0/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.1
+Name: pycivil
+Version: 0.1.0
+Summary: Structural Engineering Utilities
+Author: Luigi Paone
+Author-email: ppc.luigi.paone@gmail.com
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: Jinja2 (>=3.1.2,<4.0.0)
+Requires-Dist: fastapi (>=0.115.6,<0.116.0)
+Requires-Dist: gmsh (>=4.11.1,<5.0.0)
+Requires-Dist: matplotlib (>=3.7.2,<4.0.0)
+Requires-Dist: numpy (>=1.25.2,<2.0.0)
+Requires-Dist: odfpy (>=1.4.0,<2.0.0)
+Requires-Dist: pandas (>=2.1.0,<3.0.0)
+Requires-Dist: pexpect (>=4.8.0,<5.0.0)
+Requires-Dist: pydantic (>=2.7,<3.0)
+Requires-Dist: pydantic-settings (>=2.1.0,<3.0.0)
+Requires-Dist: pymongo (>=4.4.1,<5.0.0)
+Requires-Dist: pytest (>=8.4.1,<9.0.0)
+Requires-Dist: python-multipart (==0.0.6)
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: rich (>=13.7.1,<14.0.0)
+Requires-Dist: typing-extensions (>=4.11.0,<5.0.0)
+Requires-Dist: uvicorn (>=0.34.0,<0.35.0)
+Requires-Dist: vtk (>=9.2.6,<10.0.0)
+Requires-Dist: xstrumodeler (==0.0.1)
+Description-Content-Type: text/markdown
+
+# sws-mind
+
+## Descrizione del progetto
+
+Il progetto consiste nella realizzazione di una infrastruttura hardware e di contenuto software. Lo scopo sarà quello di consolidare il knowhow tecnico ingegneristico e per dare la possibilità ai professionisti di sws di utilizzarlo in modo confortevole per velocità ed aspetto.
+
+L'infrastruttura hardware sarà un server in grado di processare richieste di vario tipo da parte di un client. Quest'ultimo sarà totalmente agnostico delle modalità di esecuzione del server e potrà unicamente effettuare chiamate ed attendere risposte su uno dei protocolli progettati per tale scopo. Le risposte potranno essere flussi di dati o interi file.
+
+Tale suddivisione risulta necessaria per varie ragioni.
+
+1. **indipendenza di sviluppo:** significa che una volta stabilito il protocollo di comunicazione si potrà sviluppare in contemporanea sia lato server che lato client. Ad esempio durante l'aggiunta di codice nel server necessario all'esecuzione di un preciso task, il client potrà contemporaneamente essere preparato per ricevere i risultati in forma visuale.
+1. **separazione di competenze:** poichè spesso per il contenuto del codice sorgente sarà necessario il lavoro di ingegneri esperti nelle varie materie (gallerie, ponti, F.E.M.), nel lavoro sul client si potranno utilizzare anche solo esperti informatici.
+1. **gestione multiutente** da varie parti del mondo potrebbe essere necessario effettuare richieste al server anche contemporaneamente. In tal caso sarà necessario il possesso del software all'interno dei vari client e tale software (ad esempio su tablet o pc) invierà richieste allo stesso server.
+1. **gestione della qualità** con la scoperta di errori o bugs all'interno del codice, ci si potrà concentrare sulla loro risoluzione senza necessità di aggiornare il software sul client.
+1. **closed source per clienti** sarà possibile vendere servizi o microservizi ad imprese o amministrazioni pubbliche senza che queste possano conoscere il contenuto tecnico ingegneristico e gli algoritmi necessari alla realizzazione del prodotto-servizio.
+1. **gestione delle autorizzazioni** sarà possibile ad esempio fornire l'autorizzazione ad un utente dell'organizzazione ad effettuare dei task per un determinato periodo di tempo. Potrà inoltre essere venduto un prodotto-servizio all'esterno con licenza a tempo.
+
+## Fasi di sviluppo
+
+1. **individuazione degli strumenti informatici hard e soft client e server**
+   1. Selezionare l'hardware del server e del client
+   1. Decidere il protocollo di comunicazione client/server
+1. **progettazione di alcuni piccoli prodotto-servizio o di qualche microservizio**
+1. **realizzazione dell'hardware e software necessario al server**
+   1. Realizzazione del software
+   1. Realizzazione dell'hardware
+1. **realizzazione del microservizio sul server**
+   1. implementazione del microervizio
+   1. collegare il microservizio al protocollo di comunicazione scelto
+1. **realizzazione del software su un tipo di client e testare la comunicazione col server**
+
+## Docker container
+
+You can run the REST API inside a docker container with the following command:
+
+```shell
+docker run -d Dockerfile --name pycivile -p 8000:8000 -e UVICORN_BIND=0.0.0.0
+```
+
+> **NOTE**: the environment variable UVICORN_BIND tells the web server on which address to listen to.
+> 0.0.0.0 allows you to reach the API from everywhere, but can be a security risk!
+
+Or, if you don't want to clone the repository:
+
+```shell
+docker build -t pycivile https://gitlab.com/luigi_paone/pycivile.git
+docker run -d pycivile --name pycivile -p 8000:8000 -e UVICORN_BIND=0.0.0.0
+```
+
+Or, if you're a docker-compose guy, you can run the [docker-compose.yml](docker-compose.yml) file with:
+
+```shell
+docker-compose up
+```
+
+This will also create the database (mongodb) and Code_Aster containers.
+
+### Environment variables
+
+| Name                   | Description                                  | Default                            |
+| ---------------------- | -------------------------------------------- | ---------------------------------- |
+| `WORKING_DATA_PATH`    | Path for data storage                        | `/app/working-data`                |
+| `XLS_SHEETS_DATA_PATH` | Folder with structural calculation workbooks | `/app/res/excel-structural-sheets` |
+| `DB_HOST`              | Database hostname                            | `localhost`                        |
+| `DB_PORT`              | Database Port                                | `27013`                            |
+| `DB_USERNAME`          | Database username                            | empty (no user)                    |
+| `DB_PASSWORD`          | Database password                            | empty (no password)                |
+
+## Development
+
+- Install [poetry](https://python-poetry.org/docs/#installation) and [task](https://taskfile.dev/installation/)
+- run `task init` do initialize the python environment and install the pre-commit hooks
+- before committing code changes, you can run `task` to perform automated checks. You can also run them separately:
+  - `task lint` fixes and checks the code and documentation
+  - `task mypy` performs type checking
+  - `task test` runs the tests with `pytest`
+  - `task security` scans the dependencies for known vulnerabilities
+
+> **NOTE**: the `lint` task is executed automatically when you commit the changes to ensure that only good quality code is added to the repository.
+
+## Launch tests with unittest
+
+### Local development
+
+You need to use
+
+```shell
+export BASE_PATH_RES=<resources path> && export WORKING_DATA_PATH=<working data>
+source goTests
+```
+
+where *resources path* typically is sibling of pycivil module and
+*working data* were backend can write singles job.
+
+Normally on my pc:
+
+```shell
+export BASE_PATH_RES=./res && export WORKING_DATA_PATH=$HOME/Documents/dev/run/pycivile/working-data
+```
+
+### Container development
+
+Go into container shell with:
+
+```shell
+docker compose exec -ti pycivile /bin/bash
+```
+
+and then
+
+```shell
+/bin/bash goTests
+```
+
+#### Remove all volumes
+
+This remove all volumes and data. Next relaunch the volumes will be build
+
+```shell
+docker-compose down -v
+```
+

pycivil-0.1.0/README.md

@@ -0,0 +1,121 @@
+# sws-mind
+
+## Descrizione del progetto
+
+Il progetto consiste nella realizzazione di una infrastruttura hardware e di contenuto software. Lo scopo sarà quello di consolidare il knowhow tecnico ingegneristico e per dare la possibilità ai professionisti di sws di utilizzarlo in modo confortevole per velocità ed aspetto.
+
+L'infrastruttura hardware sarà un server in grado di processare richieste di vario tipo da parte di un client. Quest'ultimo sarà totalmente agnostico delle modalità di esecuzione del server e potrà unicamente effettuare chiamate ed attendere risposte su uno dei protocolli progettati per tale scopo. Le risposte potranno essere flussi di dati o interi file.
+
+Tale suddivisione risulta necessaria per varie ragioni.
+
+1. **indipendenza di sviluppo:** significa che una volta stabilito il protocollo di comunicazione si potrà sviluppare in contemporanea sia lato server che lato client. Ad esempio durante l'aggiunta di codice nel server necessario all'esecuzione di un preciso task, il client potrà contemporaneamente essere preparato per ricevere i risultati in forma visuale.
+1. **separazione di competenze:** poichè spesso per il contenuto del codice sorgente sarà necessario il lavoro di ingegneri esperti nelle varie materie (gallerie, ponti, F.E.M.), nel lavoro sul client si potranno utilizzare anche solo esperti informatici.
+1. **gestione multiutente** da varie parti del mondo potrebbe essere necessario effettuare richieste al server anche contemporaneamente. In tal caso sarà necessario il possesso del software all'interno dei vari client e tale software (ad esempio su tablet o pc) invierà richieste allo stesso server.
+1. **gestione della qualità** con la scoperta di errori o bugs all'interno del codice, ci si potrà concentrare sulla loro risoluzione senza necessità di aggiornare il software sul client.
+1. **closed source per clienti** sarà possibile vendere servizi o microservizi ad imprese o amministrazioni pubbliche senza che queste possano conoscere il contenuto tecnico ingegneristico e gli algoritmi necessari alla realizzazione del prodotto-servizio.
+1. **gestione delle autorizzazioni** sarà possibile ad esempio fornire l'autorizzazione ad un utente dell'organizzazione ad effettuare dei task per un determinato periodo di tempo. Potrà inoltre essere venduto un prodotto-servizio all'esterno con licenza a tempo.
+
+## Fasi di sviluppo
+
+1. **individuazione degli strumenti informatici hard e soft client e server**
+   1. Selezionare l'hardware del server e del client
+   1. Decidere il protocollo di comunicazione client/server
+1. **progettazione di alcuni piccoli prodotto-servizio o di qualche microservizio**
+1. **realizzazione dell'hardware e software necessario al server**
+   1. Realizzazione del software
+   1. Realizzazione dell'hardware
+1. **realizzazione del microservizio sul server**
+   1. implementazione del microervizio
+   1. collegare il microservizio al protocollo di comunicazione scelto
+1. **realizzazione del software su un tipo di client e testare la comunicazione col server**
+
+## Docker container
+
+You can run the REST API inside a docker container with the following command:
+
+```shell
+docker run -d Dockerfile --name pycivile -p 8000:8000 -e UVICORN_BIND=0.0.0.0
+```
+
+> **NOTE**: the environment variable UVICORN_BIND tells the web server on which address to listen to.
+> 0.0.0.0 allows you to reach the API from everywhere, but can be a security risk!
+
+Or, if you don't want to clone the repository:
+
+```shell
+docker build -t pycivile https://gitlab.com/luigi_paone/pycivile.git
+docker run -d pycivile --name pycivile -p 8000:8000 -e UVICORN_BIND=0.0.0.0
+```
+
+Or, if you're a docker-compose guy, you can run the [docker-compose.yml](docker-compose.yml) file with:
+
+```shell
+docker-compose up
+```
+
+This will also create the database (mongodb) and Code_Aster containers.
+
+### Environment variables
+
+| Name                   | Description                                  | Default                            |
+| ---------------------- | -------------------------------------------- | ---------------------------------- |
+| `WORKING_DATA_PATH`    | Path for data storage                        | `/app/working-data`                |
+| `XLS_SHEETS_DATA_PATH` | Folder with structural calculation workbooks | `/app/res/excel-structural-sheets` |
+| `DB_HOST`              | Database hostname                            | `localhost`                        |
+| `DB_PORT`              | Database Port                                | `27013`                            |
+| `DB_USERNAME`          | Database username                            | empty (no user)                    |
+| `DB_PASSWORD`          | Database password                            | empty (no password)                |
+
+## Development
+
+- Install [poetry](https://python-poetry.org/docs/#installation) and [task](https://taskfile.dev/installation/)
+- run `task init` do initialize the python environment and install the pre-commit hooks
+- before committing code changes, you can run `task` to perform automated checks. You can also run them separately:
+  - `task lint` fixes and checks the code and documentation
+  - `task mypy` performs type checking
+  - `task test` runs the tests with `pytest`
+  - `task security` scans the dependencies for known vulnerabilities
+
+> **NOTE**: the `lint` task is executed automatically when you commit the changes to ensure that only good quality code is added to the repository.
+
+## Launch tests with unittest
+
+### Local development
+
+You need to use
+
+```shell
+export BASE_PATH_RES=<resources path> && export WORKING_DATA_PATH=<working data>
+source goTests
+```
+
+where *resources path* typically is sibling of pycivil module and
+*working data* were backend can write singles job.
+
+Normally on my pc:
+
+```shell
+export BASE_PATH_RES=./res && export WORKING_DATA_PATH=$HOME/Documents/dev/run/pycivile/working-data
+```
+
+### Container development
+
+Go into container shell with:
+
+```shell
+docker compose exec -ti pycivile /bin/bash
+```
+
+and then
+
+```shell
+/bin/bash goTests
+```
+
+#### Remove all volumes
+
+This remove all volumes and data. Next relaunch the volumes will be build
+
+```shell
+docker-compose down -v
+```

pycivil-0.1.0/pycivil/EXAExceptions.py

@@ -0,0 +1,8 @@
+from typing import Any
+
+
+class EXAExceptions(Exception):
+    def __init__(self, error: str, message: str, number: Any = None) -> None:
+        self.error = error
+        self.message = message
+        self.number = number

pycivil-0.1.0/pycivil/EXAGeometry/clouds.py

@@ -0,0 +1,298 @@
+import copy
+import pickle
+from typing import List, Any, Tuple, Union, Optional
+from warnings import warn
+from pathlib import Path
+from pydantic import BaseModel
+
+from pycivil.EXAGeometry.geometry import Point2d, Vector2d, Seg2d, Point2dMdl
+
+
+class PointCloud2dMdl(BaseModel):
+    points: Optional[List[Point2dMdl]] = None
+
+
+class PointCloud2d:
+    def __init__(self, *args):
+
+        if len(args) == 0:
+            self.__points: List[Point2d] = []
+            self.__metaData: List[List[Any]] = []
+            self.__signs: List[float] = []
+
+        elif len(args) == 1 and isinstance(args[0], list):
+            if len(args[0]) == 0:
+                self.__points: List[Point2d] = []
+                self.__metaData: List[List[Any]] = []
+                self.__signs: List[float] = []
+            else:
+                self.__points: List[Point2d] = [Point2d()] * len(args[0])
+                self.__signs: List[float] = [0.0] * (len(args[0]) - 2)
+                if isinstance(args[0][0], list):
+                    self.__metaData: List[List[Any]] = [[]] * len(args[0])
+                    for idx in range(len(self.__points)):
+                        metaLenght = len(args[0][idx])
+                        assert metaLenght >= 2
+
+                        assert isinstance(args[0][idx][0], (float, int))
+                        assert isinstance(args[0][idx][1], (float, int))
+                        self.__points[idx] = Point2d(args[0][idx][0], args[0][idx][1])
+
+                        if metaLenght >= 2:
+                            self.__metaData[idx] = args[0][idx][2:(metaLenght + 1)]
+
+                        if idx >= 2:
+                            vecStart = Vector2d(
+                                self.__points[idx - 2], self.__points[idx - 1]
+                            )
+                            vecEnd = Vector2d(self.__points[idx - 1], self.__points[idx])
+                            self.__signs[idx - 2] = vecStart.cross(vecEnd)
+
+                elif isinstance(args[0][0], Point2d):
+                    self.__metaData: List[List[Any]] = []
+                    for idx in range(len(self.__points)):
+                        assert isinstance(args[0][idx], Point2d)
+                        self.__points[idx] = args[0][idx]
+                        if idx >= 2:
+                            vecStart = Vector2d(
+                                self.__points[idx - 2], self.__points[idx - 1]
+                            )
+                            vecEnd = Vector2d(self.__points[idx - 1], self.__points[idx])
+                            self.__signs[idx - 2] = vecStart.cross(vecEnd)
+                else:
+                    raise ValueError("Only list or Point2d for first arg !!!")
+
+        elif len(args) == 1 and isinstance(args[0], PointCloud2dMdl):
+            self.__metaData: List[List[Any]] = []
+            self.__signs: List[float] = []
+            self.__points: List[Point2d] = []
+            if args[0].points is not None:
+                for p in args[0].points:
+                    self.__points.append(Point2d(x=p.xy[0],y=p.xy[1]))
+        else:
+            raise ValueError("Only one arg list or PointCloud2dMdl !!!")
+
+        self.__index = 0
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.__index < len(self.__points):
+            item = self.__points[self.__index]
+            self.__index += 1
+            return item
+        else:
+            raise StopIteration
+
+    def __getitem__(self, key):
+        print(f"self.__points = {self.__points}")
+        return self.__points[key]
+
+    def __str__(self):
+        dispstr = self.__points.__str__()
+        return dispstr
+
+    def __len__(self):
+        return len(self.__points)
+
+    def isConvex(self) -> bool:
+        if len(self.__signs) > 0:
+            s = self.__signs[0] > 0
+            for i in range(1, len(self.__signs)):
+                if (self.__signs[i] > 0) != s:
+                    return False
+            return True
+        print(
+            "WARNING: Can't know about convexity because lenght is null !!!. Return False"
+        )
+        return False
+
+    def __eq__(self, __value) -> bool:
+        if len(__value) != len(self):
+            return False
+        for idx in range(len(__value)):
+            if self.__points[idx] != __value[idx]:
+                return False
+        return True
+
+    def getPoints(self):
+        return self.__points
+
+    def getMetaAt(self, idx: int) -> List[Any]:
+        return self.__metaData[idx]
+
+    def boundingBox(self) -> Tuple[float, float, float, float]:
+        bb = [0.0, 0.0, 0.0, 0.0]
+        for p in self.__points:
+            if p.x < bb[0]:
+                bb[0] = p.x
+            if p.x > bb[1]:
+                bb[1] = p.x
+            if p.y < bb[2]:
+                bb[2] = p.y
+            if p.y > bb[3]:
+                bb[3] = p.y
+
+        return bb[0], bb[1], bb[2], bb[3]
+
+    def contains(
+        self,
+        xp: float,
+        yp: float,
+        ro: Tuple[float, float],
+        convex: bool = True,
+        rayFromCenter=True,
+        center: Union[Point2d, None] = None,
+    ):
+
+        if center is None:
+            center = Point2d(0.0, 0.0)
+
+        if not isinstance(xp, float) and not isinstance(yp, int):
+            raise ValueError("Only float or int type for N!!!")
+
+        if not isinstance(xp, float) and not isinstance(yp, int):
+            raise ValueError("Only float or int type for M!!!")
+
+        if not convex:
+            raise ValueError("Only algorithm for convex shape !!!")
+
+        if len(self.__points) < 3:
+            raise ValueError("Containts at least 3 points !!!")
+
+        p = Point2d(xp, yp)
+
+        # ro useful for intersection point. Normally ro is estimed
+        # with boudingbox calculated during forming interaction
+        # domain.
+        rox = ro[0]
+        roy = ro[1]
+
+        contained: bool = True
+        pintersect: List[Point2d] = []
+        pintersectFactor: float = 0.0
+        pintersectFactors: List[float] = []
+        pindex: List[int] = []  # Index that intersection found
+
+        p1 = self.__points[0]
+        p2 = self.__points[0 + 1]
+        v2 = Vector2d(p2, p1)
+        v1 = Vector2d(p1, p)
+
+        minLenght = v1.norm_roxroy(rox, roy)
+        if rayFromCenter:
+            normro = False
+            seg = Seg2d(p2, p1)
+            ray = Seg2d(p, center)
+            hasIntersection, pint = seg.intersectAndContaints(ray)
+            if hasIntersection:
+                pintersect.append(pint)
+                pintersectFactors.append(ray.extensionFactor(pint))
+                pindex.append(0)
+        else:
+            normro = True
+
+        minPoint = p1
+        cross = v1.cross(v2)
+        check_contained = True
+        for i, _val in enumerate(self.__points[0: len(self.__points) - 2], 1):
+            p1 = self.__points[i]
+            p2 = self.__points[i + 1]
+            v2 = Vector2d(p2, p1)
+            v1 = Vector2d(p1, p)
+            if normro:
+                minLenght_i = v1.norm_roxroy(rox, roy)
+                if minLenght_i < minLenght:
+                    minLenght = minLenght_i
+                    minPoint = p1
+            elif rayFromCenter:
+                # if (p2 != p1):
+                seg = Seg2d(p2, p1)
+                ray = Seg2d(p, center)
+                hasIntersection, pint = seg.intersectAndContaints(ray)
+                if hasIntersection:
+                    found = False
+                    for ii in pintersect:
+                        # Relative precision for excluding nearest points for
+                        # some case precision issue
+                        # We can not use i==pint
+                        if ii.isEqualTo(pint, rox, roy, 1e-9):
+                            found = True
+                    if not found:
+                        pintersect.append(pint)
+                        pintersectFactors.append(ray.extensionFactor(pint))
+                        pindex.append(i)
+            else:
+                minLenght_i = v1.norm()
+                if minLenght_i < minLenght:
+                    minLenght = minLenght_i
+                    minPoint = p1
+
+            cross_new = v1.cross(v2)
+            if cross * cross_new < 0 and check_contained:
+                contained = False
+                check_contained = False
+            cross = cross_new
+
+        pindexn = -1
+        d1 = 0
+        d2 = 0
+        d3 = 0
+
+        if normro:
+            warn("normro not tested !!!")
+            return contained, minLenght, minPoint, None
+
+        if len(pintersect) != 2:
+            print("WARNING: intersection are %1.2i not 2 !!!" % len(pintersect))
+            for p in pintersect:
+                print(p)
+            return contained, pintersect, pintersectFactor, [pindexn, d1, d2, d3]
+
+        if pintersectFactors[0] < 0:
+            pintersectFactor = pintersectFactors[1]
+            pindexn = pindex[1]
+            pleft = self.__points[pindex[1]]
+            pright = self.__points[pindex[1] + 1]
+            d1 = pintersect[1].distance(pleft)
+            d2 = pintersect[1].distance(pright)
+            d3 = pleft.distance(pright)
+            ptemp = copy.deepcopy(pintersect)
+            pintersect[0] = ptemp[1]
+            pintersect[1] = ptemp[0]
+        else:
+            pintersectFactor = pintersectFactors[0]
+            pindexn = pindex[0]
+            pleft = self.__points[pindex[0]]
+            pright = self.__points[pindex[0] + 1]
+            d1 = pintersect[0].distance(pleft)
+            d2 = pintersect[0].distance(pright)
+            d3 = pleft.distance(pright)
+
+        if pintersectFactor < 1.0:
+            contained = False
+        else:
+            contained = True
+
+        return contained, pintersect, pintersectFactor, [pindexn, d1, d2, d3]
+
+    def save(self, file: Path):
+        toSave = {
+            "points": self.__points,
+            "metaData": self.__metaData
+        }
+        with open(file, "bw") as f:
+            pickle.dump(toSave, f)
+
+    def open(self, file: Path):
+        with open(file, "br") as f:
+            toRead = pickle.load(f)
+            self.__points = toRead["points"]
+            self.__metaData = toRead["metaData"]
+
+    def model(self) -> PointCloud2dMdl:
+        points: List[Point2dMdl] = [Point2dMdl(x=i, y=i, null=True) for i in range(len(self.__points))]
+        for i, p in enumerate(points):
+            p.xy = (self.__points[i].x, self.__points[i].y)
+        return PointCloud2dMdl(points=points)