semvec/pypi-packages huggingface dataset:
arcade_notion_toolkit 0.1.0
Notion integration to search, create, update, and delete databases/pages.
Requires Python: <4.0,>=3.10

# Arcade Notion Toolkit

An Arcade AI toolkit designed to interact with Notion, enabling users to find and create pages and databases.

## Features

- **Page & Database Discovery**: Easily find pages and databases by their titles and get their IDs for follow-up operations
- **Content Creation**: Generate new pages and databases with AI-assisted content population
- **Secure OAuth Integration**: Built-in secure authentication flow with Notion's OAuth 2.0

## Roadmap

- [ ] Update existing pages and databases
- [ ] Delete pages and databases
- [ ] Test suite
- [ ] Evaluate tools

## Prerequisites

Before getting started, ensure you have:

- A Notion account with administrative access
- Permission to create and manage integrations
- Access to target pages/databases

## Configuration

### 1. Create a Notion Integration

1. Follow the [Create a Public Integration](https://developers.notion.com/docs/authorization#public-integration-auth-flow-set-up) guide
2. Set the redirect URI to: `https://cloud.arcade-ai.com/api/v1/oauth/callback`
3. Save your client ID and secret

### 2. Environment Setup

Add these variables to your `arcade.env`:

```env
NOTION_CLIENT_ID=your_client_id
NOTION_CLIENT_SECRET=your_client_secret
```

### 3. OAuth Configuration

Add this configuration to your Arcade engine setup:

```yaml
auth:
  providers:
    - id: notion
      enabled: true
      type: oauth2
      description: "Notion OAuth 2.0 provider"
      client_id: ${env:NOTION_CLIENT_ID}
      client_secret: ${env:NOTION_CLIENT_SECRET}
      oauth2:
        authorize_request:
          endpoint: "https://api.notion.com/v1/oauth/authorize"
          params:
            response_type: "code"
            client_id: "{{client_id}}"
            redirect_uri: "{{redirect_uri}}"
            owner: "user"
        token_request:
          endpoint: "https://api.notion.com/v1/oauth/token"
          params:
            grant_type: "authorization_code"
            redirect_uri: "{{redirect_uri}}"
          auth_method: "client_secret_basic"
```

## Usage Examples

### Finding Resources

```plaintext
# Find a database
"Get me the database ID for 'Project Tracker'"

# Locate a specific page
"What's the ID of the page called 'Meeting Notes'?"
```

### Creating Content

```plaintext
# Create a new project page
"Create a new page titled 'Mobile App Redesign' in the 'Project Ideas' database and populate it with ideas generated from our recent discussion"


# Create meeting notes
"Create a new page titled 'Client Discussion' within the 'Meeting Notes' database, including all the notes from today's meeting"
```
stellarismodparser 1.0.7
Parse Stellaris's mod descriptor files.
Requires Python: >=3.9

# StellarisModParser

[<img alt="PyPI - Version" src="https://img.shields.io/pypi/v/stellarismodparser">](https://pypi.org/project/stellarismodparser/)
[<img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/stellarismodparser">](https://pypi.org/project/stellarismodparser/)
[<img alt="PyPI - License" src="https://img.shields.io/pypi/l/stellarismodparser">](https://www.coastalcommits.com/Seaswimmer/StellarisModParser/src/branch/master/LICENSE/)  
This package provides a simple parser for Stellaris's mod descriptor format.

## Usage

```python-repl
>>> import stellarismodparser
>>> path = "/home/seaswimmer/Projects/StellarisMods/No Menacing Ships.mod"
>>> mod = stellarismodparser.parse(path)
>>> mod.name
'No Menacing Ships'
>>> str(mod.supported_version)
'Andromeda 3.12.4'
>>> mod.tags
['Balance', 'Gameplay']
```
pyobjloader 0.0.7
An obj model loader for Python

# PyObjLoader
An obj model loader for python. Ideal for 3D data and graphics. 
Includes object and group trees, and automatic normal, tangent, and bitangent calculations. 

## Setup
Run the install command.

```pip
pip install pyobjloader
```

## Import
Import the load function

```py
from pyobjloader import load_model 
```

## Use
To get the numpy array of vertices, first place the .obj somewhere in your project file (example shown)

```
project
│ main.py
│ my_model_directory
└─── my_model.obj
```

Then pass the file path into the load function
```py
model = load_model('my_model_directory/my_model.obj')
vertex_data = model.vertex_data
```
Examples for how to access more data from the model are in the github examples folder.

## Format
The format of the vertex data for an obj is stored in the model:

```py
# ModernGL Specifications
vertex_format = model.format  # ie. '3f 2f 3f'
vertex_attribs = model.attribs  # ie. ['in_position', 'in_uv', 'in_normal']
```

Possible attributes include `['in_position', 'in_uv', 'in_normal']` and `['in_position', 'in_normal']` (Normals are calculated if not given)

## Example with ModernGL
Here is an example VAO made with ModernGL and PyObjLoader

```py
# Make sure you have a context and shader program (see moderngl docs)
ctx = ...
program = ...

# Load the model using pyobjloader
model = load_model('my_model_directory/my_model')
vertex_data = model.vertex_data

# Make a vertex buffer object with the vertex data
vbo = ctx.buffer(vertex_data)

# Create a vertex array object
vao = ctx.vertex_data(program, [(vbo, model.format, *model.attribs)])
```

##
sympla-tools 0.3.1
SDK para integração com a API da Sympla
Requires Python: ==3.10.14

# SymplaTools SDK

SymplaTools é um SDK para integração com a plataforma Sympla, atualmente incluindo funcionalidades como:

* Validação de QR codes assinados com ECDSA.

---

# Pypi

Este projeto está em um repositório público, e tem como objetivo facilitar o uso das funcionalidades da Sympla.

https://pypi.org/project/sympla_tools/

###  Também disponível no package registry do gitlab

https://gitlab.com/symplax/sympla-tools/-/packages

---

## Instalação

Para instalar as dependências, use [Poetry](https://python-poetry.org/):

```bash
### Pypy
poetry add sympla-tools


### Package registry Gitlab
poetry add git+ssh://git@gitlab.com:gitlab.com/symplax/sympla-tools/-/packages#0.1.5
```

## Configuração

Para validar a assinatura, é necessário definir o endereço Ethereum conhecido (`KNOWN_ETHEREUM_ADDRESS`) como uma variável de ambiente. Este será o endereço usado para verificar a autenticidade da assinatura do QR code.

Configure o endereço Ethereum conhecido com o seguinte comando:

```bash
export KNOWN_ETHEREUM_ADDRESS="0xdB074b3c323A7Ad418EBBe66baD231f43f680563"
```

## Uso

Após configurar o endereço Ethereum, você pode usar o SDK para validar a assinatura de um QR code Ethereum.


### Você vai precisar ler o Qrcode

Para realizar a validação, será necessário construir o json contendo os campo em ordem:

* address
* ItemTypeId

Além do json, é necessário resgatar a assinatura (signature)

### Exemplo de uso via linha de comando

Para validar uma assinatura via linha de comando, execute:

```bash
python -m sympla_tools.tickets.signature.ethereum_token validate '{"address": "0x3e3857e99BE213aA914942C6482c33161Df51E16", "ItemTypeId": "37884525610813"}' '0x1e6912e765694db61b5291c94469ba339f1b7da3e921d5c3acd8ced279565053120e3e866c0158fe0eeddefdd113303adc1e56e79a9f1503386251786d4881f31b'
```

Substitua `"ASSINATURA"` pela assinatura que deseja validar. O SDK verificará se a assinatura corresponde ao endereço Ethereum configurado.

### Gerando um binário 

Este projeto consegue rodar através de um binário, para isto você precisa gerar o build do pacote

```bash
python sympla_tools/scripts/build_binary.py

### depois copie o binario gerado para a pasta bin
/usr/local/bin
```

### Funções Principais

- **validate**: Função principal para validar uma assinatura Ethereum. A função compara a assinatura com o endereço configurado e retorna se a assinatura é válida.
gensec 0.0.5
A Python package for generating secure docker and k8s resources

# gensec

gensec is a command-line tool designed to simplify the process of generating scure configuration files such as Dockerfiles and Helm charts. The CLI prompts users for input as needed and includes interactive options to customize configurations effectively.


## Features

- **Generate Dockerfiles**: Create secure and customizable Dockerfiles for different programming languages.
- **Generate Helm charts**: Create Helm chart templates for Kubernetes deployments.
- **List available commands**: Display the available commands and their descriptions.

## Installation

You can install the `gensec` package directly from PyPI:
```

bash pip install gensec

```

# Usage

After installing the package, you can use the following commands:

## List Available Commands
To list all available commands, run:
```
gensec list
```

## Generate a Dockerfile
To generate a Dockerfile, use the dockerfile command:
```
gensec dockerfile --language <programming_language> --port <port_number> --entrypoint <entry_point>

```

If the details are not provided, the tool will prompt you to select the language, port, and entrypoint interactively.

## Generate a Helm Chart
To generate a Helm chart, use the helmchart command:
```
gensec helmchart --name <service_name>
```
If the details are not provided, the tool will prompt you to enter the service name interactively.
shore-pkg-geonda 0.1.4
python wrapper for OCEAN-FEFF

# shore
Python wapper for OCEAN(FEFF) code.
Calculates XAS.


### The structure of the code:
<img src="img/img2.png" alt="drawing" width="700"/>

### The input object structure:
<img src="img/img3.png" alt="drawing" width="700"/>