semvec/pypi-packages huggingface dataset:
ptl-si 0.1.0
PTL-SI: Statistical inference for high-dimensional regression after transfer learning
Requires Python: >=3.6

# PTL-SI: Post-Transfer Learning Statistical Inference in High-Dimensional Regression
**PTL-SI** is a Python package designed for conducting valid statistical inference in high-dimensional regression (HDR) settings with transfer learning (TL). It implements selective inference methods to control the false positive rate (FPR) while maximizing the true positive rate (TPR) in feature selection after transfer learning.


## Requirements & Installation
This package has the following requirements:
- [`numpy`](https://numpy.org/doc/stable/)
- [`mpmath`](https://mpmath.org/)
- [`skglm`](https://contrib.scikit-learn.org/skglm/)
- [`scipy`](https://docs.scipy.org/doc/)
- [`matplotlib`](https://matplotlib.org/)
- [`statsmodels`](https://www.statsmodels.org/stable/index.html)


This package can be installed using pip:
```bash
pip install ptl_si
```

We recommend to install or update anaconda to the latest version and use Python 3 (We used Python 3.11.4).
typer-pydantic-config 0.5.0
Use [pydantic](https://docs.pydantic.dev/latest/) to manage persistent config for your [Typer](https://typer.tiangolo.com/) CLI apps!
Requires Python: >=3.12
Keywords: CLI, config, pydantic, python, typer

# Typer Pydantic Config

This package helps you quickly build python CLI applications with a persistent config using [typer](https://typer.tiangolo.com/) & [pydantic](https://docs.pydantic.dev/latest/).

![minimal_example.gif](https://github.com/david-fischer/typer-pydantic-config/blob/main/assets/minimal_example.gif)

See [minimal.py](src/examples/minimal.py) and [example.py](src/examples/example.py) for two simple examples.

## Installation
Install it from [pypi](https://pypi.org/project/typer-pydantic-config/) using your preferred method, e.g. through [uv](https://github.com/astral-sh/uv):
```bash
uv pip install typer-pydantic-config
```

## Usage

1. Implement config object as [pydantic](https://docs.pydantic.dev/latest/) class
2. Use `get_config` where every you need the config object
3. Build your [typer](https://typer.tiangolo.com/) app
4. Start the app with `start_config_app(app, <YourConfigPydanticClass>)`

On the first invocation, prompts the user to set all values in the config file.

Your app now has an additional `config` command with the following signature:
```text
$ python example.py config --help
Usage: example.py config [OPTIONS] COMMAND [ARGS]...

  Interact with config: (delete | init | path | set | show).

Options:
  --help  Show this message and exit.

Commands:
  delete  Delete config file on disk.
  init    Interactively prompt for every field in the config.
  path    Print config path.
  set     Set one or more config fields via flags.
  show    Print content of config file.
```


## ⚠ Current Limitations ⚠
 * The package is still an early draft and not yet thoroughly tested
 * Only `default_factory` without arguments is supported
 * Does not support optional fields yet
 * The following types are supported as attributes of your config class:
   * int
   * float
   * bool
   * str
   * datetime
   * Path
   * another subclass of pydantic's `BaseModel`
 * Config values are available as `ctx.obj["config"]` (see [click docs: Context](https://click.palletsprojects.com/en/stable/api/#click.Context)).
   * This is only available when one of the endpoint functions is called.
   * Do not overwrite the `ctx.obj` (at least not the `"config"` key).
 * Unique app name required:
   * Set a unique name: `app = typer.Typer(name="<some_unique_name>")`
   * This name is used by [platformdirs](https://github.com/tox-dev/platformdirs) to construct the path of the config.
feagi-connector 0.0.40
Feagi agent to work with general and simulation robots
Requires Python: >=3.6

# What is feagi-connector?
The feagi-connector is the core of the Feagi agent and it serves multiple purposes. It works behind the scenes and serves as an API for Feagi.
Keep in mind, you will need Feagi to connect with feagi_connector. Feagi can be running on a website, Docker, or locally on your computer. 

If you would like to learn more about how to run Feagi, please visit: https://github.com/feagi/feagi/tree/staging

# Quick Start:
You can start with any of the quick start options. The easiest and simplest method is to use feagi_connector_video_capture, which focuses solely on video capture functionality. Once you have installed it using pip3 install feagi_connector_video_controller, simply type python3 -m feagi_connector_video_controller --ip 127.0.0.1 to run it.

If you would like to create your own code using the Feagi API and call `feagi_interface` or `retina`, you can use the following code:

`from feagi_connector import feagi_interface`

`from feagi_connector import retina`

# Feagi Agent Packages:
Currently, we have more than 2 packages: `feagi_connector_video_controller`, `feagi_connector_freenove`, and `feagi_connector_mycobot`. You can find more packages here: https://github.com/feagi/feagi/tree/feature-mycobot-updated/peripherals
The requirements for `feagi-connector` can be found here: [feagi-connector requirements](https://github.com/feagi/feagi/blob/staging/peripherals/feagi_connector_core/feagi_connector/requirements.txt)
scau-jwxt-auth 0.1.2
A package for authenticating with SCAU JWXT system.
Requires Python: >=3.10

# SCAU JWXT Auth

用于华南农业大学教务系统（SCAU JWXT）的身份认证库，可以一键获取鉴权所需的 Cookie 和 Headers，全天可用，自动处理夜间需要 VPN 的情况。

## 安装

```bash
pip install scau-jwxt-auth
```

## 使用方法

```python

from scau_jwxt_auth import JWXT

# 初始化 JWXT 实例
client = JWXT(user_code="your_student_id", password="your_password",  sso_password="your_sso_password")

import time
import requests

# 获取用户信息
url = (f"{client.base_url}/secService/assert.json?"
"resourceCode=resourceCode&"
"apiCode=framework.sign.controller.SignController.asserts&"
f"t={int(time.time()*1000)}&sf_request_type=ajax"
)
session = client.get_session()
response = session.get(url, timeout=15)
response.raise_for_status()

# 打印用户信息
print(response.json())

```

## 许可证

[AGPLv3](LICENSE)
embed-model 0.4.4
Um modelo de embeds não oficial para discord.py. Feito em Português.
Requires Python: >=3.8

# 📦 Discord Embed Editor Bot

Um modelo para Discord que permite editar embeds de mensagens de forma interativa utilizando **modais**, **botões** e **menus de seleção** da UI do Discord. Ideal para quem deseja personalizar mensagens de maneira rápida, visual e organizada.

## ✨ Funcionalidades

- 📑 Editar título, descrição, conteúdo e cor do embed.
- 🖼️ Definir ou alterar thumbnail, imagem principal e timestamp.
- 👣 Editar o footer (texto e imagem).
- ➕ Adicionar novos fields (campos) ao embed.
- ✏️ Editar campos existentes.
- 🗑️ Remover campos específicos.
- ✅ Confirmar e enviar embeds editados.
- ❌ Cancelar e excluir mensagens temporárias de edição.

## 📦 Tecnologias Utilizadas

- [Python 3.11+](https://www.python.org/)
- [discord.py 2.x](https://discordpy.readthedocs.io/en/stable/)
- Componentes interativos: `discord.ui.Modal`, `discord.ui.Button`, `discord.ui.Select`

## 🚀 Como usar

1. Clone o repositório:
   ```bash
   git clone https://github.com/LucaCunha001/DiscordEmbedModel.git
   cd DiscordEmbedModel.git
package-shakarpg 0.0.1
projeto pypi
Requires Python: >=3.8

# package_shakarpg

## Description
The package package_shakarpg is used to:
- Image
- Image2

## Installation
Use the package manager [pip](https://pip.pypa.io/en/stable/) to install package_shakarpg

```bash
pip install package_name
```

## Usage

```python
from package_shakarpg.image import show_image
show_image("path/to/image1.jpg")

from package_shakarpg.image2 import show_image2
show_image2("path/to/image2.jpg")
```

## Author
Shakarpg

## License
[MIT](https://choosealicense.com/licenses/mit/)
subregistry 0.1.1
Utility Python library to easily create registries of sub-classes and import them conveniently.
Requires Python: >=3.10

# subregistry

Utility Python library to easily create registries of sub-classes and import them conveniently.

## Installation

```bash
pip install subregistry
```

## Usage

To add a registry to a class, simply import and use the decorator:

```python
from subregistry import add_registry

@add_registry
class BaseClass:
    pass
```

Any **Imported** subclass of `BaseClass` will then automatically be registered.

Registered subclasses can later be retrieved by name as follows:

```python
BaseClass.registry.get_by_name("SubClass")
```

See the `examples` folder for more in-depth usages.

## Author

* Thomas Havy
boring-catalog 0.1.1
A DuckDB-based Iceberg catalog implementation
Requires Python: >=3.10

# Boring Catalog

A DuckDB-based Iceberg catalog implementation.

The catalog is stored as a single .duckdb file in S3, making it lightweight and portable.

## Why Boring Catalog?
- Eliminates the need to host or maintain a dedicated catalog service
- We can store all our Iceberg metadata in a single DuckDB file, including:
  - Catalog metadata
  - Pointers to Iceberg metadata files (via `read_json('s3://...')`)
  - References to Iceberg table data (via `scan_iceberg('s3://...')`)
- Enables easy sharing across teams and environments through simple S3 URLs using `ATTACH '<s3_url>'`
- We can easily expose a FastAPI REST endpoint to enable writes from Snowflake and other external systems

## How It Works

Boring Catalog uses S3 conditional PUT operations to synchronize the catalog across multiple clients, effectively preventing race conditions during concurrent access.

## Installation

```bash
pip install boring-catalog
```

## Usage

### Create namespace and table

```python
from boring_catalog import BoringCatalog
from pyiceberg.schema import Schema
from pyiceberg.types import LongType, StringType, DecimalType
from pyiceberg.schema import NestedField

catalog = BoringCatalog(
    "my_catalog",
    warehouse="s3://{your-bucket}/boringcatalog"
)

if ("my_namespace",) not in catalog.list_namespaces():
    catalog.create_namespace("my_namespace")

schema = Schema(
    NestedField(1, "id", LongType(), required=True),
    NestedField(2, "data", StringType()),
    NestedField(3, "amount", DecimalType(5, 1))
)

if ("my_namespace", "my_table_2") not in catalog.list_tables():
    table = catalog.create_table(
        identifier=("my_namespace", "my_table_2"),
        schema=schema,
        properties={"write.format.default": "parquet"}
    )
```


### Append data

```python
from boring_catalog import BoringCatalog
from pyiceberg.schema import Schema
from pyiceberg.types import LongType, StringType, DecimalType
from pyiceberg.schema import NestedField

catalog = BoringCatalog(
    "my_catalog",
    warehouse="s3://{your-bucket}/boringcatalog"
)

table = catalog.load_table(("my_namespace", "my_table_2"))

dummy_data = pd.DataFrame({
    "id": pd.Series(range(1, 10001), dtype="Int32"), 
    "data": [f"Transaction_{i}" for i in range(1, 10001)],
    "amount": [Decimal(str(min(i * 10.5, 9999.9))).quantize(Decimal('0.1')) for i in range(1, 10001)]   
})

arrow_table = pa.Table.from_pandas(
    dummy_data,
    schema=pa.schema([
        ('id', pa.int32(), False), 
        ('data', pa.string(), True),
        ('amount', pa.decimal128(5, 1), True) 
    ]),
    safe=True
)

table.append(arrow_table)
```

Next steps:
[] Reflect tables in the catalog (CREATE VIEW AS SELECT * FROM READ_ICEBERG())
[] Reflect snapshots in a catalog table (CREATE TABLE snapshots as read_json())
[] Improve performance (sync of .duckdb from local to s3 takes too long)
[] Add fastAPI on top of the catalog to allow write from Snowflake and other clients