semvec/pypi-packages huggingface dataset:
internal-lib-48e662a6 0.1.0a6
Internal utility package
Requires Python: >=3.8

# Sage X3 Requests Wrapper (ALPHA)

> ⚠️ **AVISO: BIBLIOTECA EM DESENVOLVIMENTO (ALPHA)** ⚠️
>
> Esta biblioteca foi publicada para uso pessoal e testes. **Não é recomendada para produção.**
> A API pode mudar drasticamente a qualquer momento sem aviso prévio. Use por sua conta e risco.

## Instalação

```bash
pip install internal-lib-48e662a6
```

## Exemplos de Uso

### Configuração
```python
from sage_x3_requests import SageX3Config, SageX3Requester

config = SageX3Config(
    base_url="https://seu-erp.com",
    username="admin",
    password="password",
    folder="SEED"
)
```

### Pedir 5 Registos (Limit)
Pode passar o limite diretamente no método `.get_resources(limit=5)`.

```python
with SageX3Requester(config) as client:
    # Opção 1: Passar limit no get_resources (Maneira mais simples!)
    registos = client.request("CLIENTES", "BPC") \
                     .get_resources(limit=5)
    
    # Opção 2: Usar .count(5) antes
    registos = client.request("CLIENTES", "BPC") \
                     .count(5) \
                     .get_resources()
```

### Pedir TODOS os Registos (Paginação Automática)
Use `.get_resources(fetch_all=True)` para buscar todos os dados, percorrendo todas as páginas automaticamente.

```python
with SageX3Requester(config) as client:
    # Busca todos os clientes (cuidado com grandes volumes de dados!)
    todos_clientes = client.request("CLIENTES", "BPC") \
                           .get_resources(fetch_all=True)
                           
    print(f"Total encontrado: {len(todos_clientes)}")
```

### Contagem Total
Para saber quantos registos existem sem trazer os dados:

```python
with SageX3Requester(config) as client:
    query = client.request("CLIENTES", "BPC").count(True).execute()
    total = query.get("count") # ou verificar estrutura de retorno
```
phases 1.4.1
An Execution Framework for pyPhase projects
Requires Python: >=3.6

# pyPhase Project-builder

This Generator will create a ready-to-go pyPhase-Project, based on a config-Yaml.

## Setup

`pip install phases`

## create `project.yaml`

### minimal
```YAML
name: myProject
namespace: myGroup
phases:
    - name: Phase1
      description: my first phase
      exports: [myData]
    - name: Phase2
      description: my second phase
```

run with `python myProject`

### complete
```YAML
name: "sleepClassificationCNN"
namespace: tud.ibmt
exporter:
    - ObjectExporter
    - KerasExporter
phases:
    prepareData:
        - name: DataWrapper
          description: get EDF Data
          exports:
            - trainingRaw
            - validationRaw
            - evaluationRaw
        - name: EDF4SleepStages
          description: Prepare EDF Data for sleep stage recognition
          exports:
            - trainingTransformed
            - validationTransformed
    train:
        - name: SleepPhaseDetectionModel
          description: Create Model for sleep stage recognition
          exports:
            - model
    evaluate:
        - name: SleepPhaseDetectionModel
          description: Create Model for sleep stage recognition
```

### Generate

`phases create`


### Development

The generator will create stubs for each phase, exporter and generator that
does not exists in the pyPhase-Package. The stubs are in the project folder and implement empty
method that are required.

To implement your project, you only need to fill those methods. For the minimal example you need
to fill the `main`-methods of Phase1 (`myProject/phases/Phase1.py`) and Phase2.

### Execute

If you want to run the whole Project run: `python [ProjectName]` for the minimal example: `python myProject`

To run a single stage: `python [ProjectName] [StageName]` for the minimal example: `python myProject stage2`

## additional files

- `doc/` placeholder for documentation
- `.editorconfig` some settings for supporting IDE about File encoding and formats (see https://editorconfig.org/)
- `.gitignore` some folders and files that should be ignored by git (see https://git-scm.com/docs/gitignore)

- `requirements.txt` the python requirements (just pyPhases in an empty project)
- `README.md` an Readme file
- `Dockerfile` a simple dockerfile that can be used to run the project in a container (The `FROM` image should properly changed)
- `docker-compose.yml` this is a helper to create and run the container. simply run `docker-compose up` or `docker compose run --rm [projectname] [stagename]`
- `.gitlab-ci.yml` a Configuration for the Gitlab-CI Pipeline, that will be automaticly run if there is a push to gitlab
wellapi 0.9.5
A simple web framework for aws lambda
Requires Python: >=3.12

# WellAPI

[![pip](https://img.shields.io/pypi/v/wellapi?color=%2334D058)](https://pypi.org/project/wellapi/)

WellAPI is a simple web framework for work with AWS Lambda
and API Gateway. It is designed to be easy to use and flexible, allowing you to create RESTful APIs quickly and efficiently.

## Features
- Simple and intuitive API for defining routes and handling requests
- Support for middleware functions
- Automatic request validation and error handling
- Support for CORS
- Support for query parameters, path parameters, and request bodies
- Support for error handling
- Support for AWS Lambda and API Gateway

## Installation

You can install WellAPI using pip:

```bash
pip instsll wellapi
```

## Example

```python
from wellapi import WellApi

app = WellApi()

@app.get("/hello")
def hello():
    return {"message": "Hello, World!"}
```

## Local development

You can run your WellAPI application locally using the `wellapi` command:

```bash
wellapi run main:app
```


## Deploy

```python
from wellapi.build.cdk import WellApiCDK


class MyStack(Stack):
    def __init__(self, scope: Construct, id_: str, **kwargs) -> None:
        super().__init__(scope, id_, **kwargs)

        app = WellApiCDK(
            self,
            "WellApiCDK",
            app_srt="main:app",
            handlers_dir="handlers",
        )
```

### CORS
You can enable CORS for your API by setting the `cors` parameter to `True` when creating the `WellApiCDK` instance:

```python
from wellapi.build.cdk import WellApiCDK


class MyStack(Stack):
    def __init__(self, scope: Construct, id_: str, **kwargs) -> None:
        super().__init__(scope, id_, **kwargs)

        app = WellApiCDK(
            self,
            "WellApiCDK",
            app_srt="main:app",
            handlers_dir="handlers",
            cors=True,
        )
```

### Cache

You can enable caching for your API by setting the `cache_enable` parameter to `True` when creating the `WellApiCDK` instance:

```python
from wellapi.build.cdk import WellApiCDK


class MyStack(Stack):
    def __init__(self, scope: Construct, id_: str, **kwargs) -> None:
        super().__init__(scope, id_, **kwargs)

        app = WellApiCDK(
            self,
            "WellApiCDK",
            app_srt="main:app",
            handlers_dir="handlers",
            cache_enable=True,
        )
```
**!!! WARNING !!!**

Caching support only GET endpoints

### Logging

You can enable logging for your API by setting the `log_enable` parameter to `True` when creating the `WellApiCDK` instance:

```python
from wellapi.build.cdk import WellApiCDK


class MyStack(Stack):
    def __init__(self, scope: Construct, id_: str, **kwargs) -> None:
        super().__init__(scope, id_, **kwargs)

        app = WellApiCDK(
            self,
            "WellApiCDK",
            app_srt="main:app",
            handlers_dir="handlers",
            log_enable=True,
        )
```