semvec/pypi-packages huggingface dataset:
compreq 0.4.0
A library for dynamically computing Python requirements, to keep them up-to-date.
Requires Python: <4,>=3.10

# compreq

A library for dynamically computing Python requirements, to keep them up-to-date.

## Concepts

This library relies heavily on [packaging](https://packaging.pypa.io/en/stable/), and you should
understand that first.

The base types are the `Version`, `Specifier`, `SpecifierSet` and `Requirement` in `packaging` and
 `Release` and `ReleaseSet` added by this library.

For all of the base types this library adds lazy versions - which both allows reuse, but also allows
some values to be fetched from the context, instead of specified explicitly.

To resolve a lazy object into a concrete value use a `CompReq.resolve_...` method.

Finally this library adds wrappers around `pyproject.toml` and `requirements.txt` files, for getting
and setting the requirments in them.

## Example:

```python
import compreq as cr

with cr.PyprojectFile.open() as pyproject:
    prev_python_specifier = cr.get_bounds(
        pyproject.get_requirements()["python"].specifier
    ).lower_specifier_set()
    comp_req = cr.CompReq(python_specifier=prev_python_specifier)

    default_range = cr.version(
        ">=",
        cr.floor_ver(
            cr.REL_MINOR,
            cr.minimum_ver(
                cr.max_ver(cr.min_age(years=1)),
                cr.min_ver(cr.count(cr.MINOR, 3)),
            ),
        ),
    ) & cr.version("<", cr.ceil_ver(cr.REL_MAJOR, cr.max_ver()))

    dev_range = cr.version(">=", cr.floor_ver(cr.REL_MINOR, cr.max_ver())) & cr.version(
        "<", cr.ceil_ver(cr.REL_MINOR, cr.max_ver())
    )

    pyproject.set_requirements(
        comp_req,
        [
            cr.pkg("beautifulsoup4") & default_range,
            cr.pkg("packaging") & default_range,
            cr.pkg("pip") & default_range,
            cr.pkg("python") & default_range,
            cr.pkg("python-dateutil") & default_range,
            cr.pkg("requests") & default_range,
            cr.pkg("tomlkit") & default_range,
            cr.pkg("typing-extensions") & default_range,
        ],
    )
    pyproject.set_requirements(
        comp_req,
        [
            cr.pkg("black") & dev_range,
            cr.pkg("isort") & dev_range,
            cr.pkg("mypy") & dev_range,
            cr.pkg("pylint") & dev_range,
            cr.pkg("pytest") & dev_range,
            cr.pkg("taskipy") & dev_range,
            cr.pkg("types-beautifulsoup4") & default_range,
            cr.pkg("types-python-dateutil") & default_range,
            cr.pkg("types-requests") & default_range,
        ],
        "dev",
    )
```

Or see [requirements.py](https://github.com/jesnie/compreq/blob/main/requirements.py).


# References:

https://peps.python.org/pep-0440/
https://packaging.pypa.io/en/stable
furax 0.9
Operators and solvers for high-performance computing.
Requires Python: >=3.10
Keywords: scientific computing

# Furax

Furax: a Framework for Unified and Robust data Analysis with JAX.

This framework provides building blocks for solving inverse problems, in particular in the astrophysical and cosmological domains.

## Installation

You should always use a virtual environment to install packages (e.g. `venv`, `conda` environment, etc.).

Start by installing [`JAX`](https://jax.readthedocs.io/en/latest/installation.html) for the target architecture.

Furax is available as [`furax`](https://pypi.org/project/furax/) on PyPI, and can be installed with:

```bash
pip install furax
```

### Development version

Clone the repository, and navigate to the root directory of the project.
For example:

```bash
git clone git@github.com:CMBSciPol/furax.git
cd furax
```

Then, install the package with:

```bash
pip install .
```

## Developing Furax

After cloning, install in editable mode and with development dependencies:

```bash
pip install -e .[dev]
```

We use [pytest](https://docs.pytest.org/en/stable/) for testing.
You can run the tests with:

```bash
pytest
```

To ensure that your code passes the quality checks,
you can use our [pre-commit](https://pre-commit.com/) configuration:

1. Install the pre-commit hooks with

```bash
pre-commit install
```

2. That's it! Every commit will trigger the code quality checks.

## Running on JeanZay

### Load cuda and and cudnn for JAX

```bash
module load cuda/11.8.0 cudnn/8.9.7.29-cuda
```

### Create Python env (only the first time)

```bash
module load python/3.10.4 && conda deactivate
python -m venv venv
source venv/bin/activate
# install jax
pip install --upgrade "jax[cuda11_local]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
# install furax
pip install -e .[dev]
```

### launch script

To launch only the pytests

```bash
sbatch slurms/astro-sim-v100-testing.slurm
```

To launch your own script

```bash
sbatch slurms/astro-sim-v100-run.slurm yourscript.py
```

You can also allocate ressources and go into bash mode

```bash
srun --pty --account=nih@v100 --nodes=1 --ntasks-per-node=1 --cpus-per-task=10 --gres=gpu:1 --hint=nomultithread bash
module purge
module load python/3.10.4
source venv/bin/activate
module load cuda/11.8.0  cudnn/8.9.7.29-cuda
# Then do your thing
python my_script.py
pytest
```

Don't leave the bash running !! (I would suggest running script with sbatch)

### Specific for nih / SciPol project

The repo is already in the commun WORK folder, the data is downloaded and the environment is ready.

You only need to do this

```bash
cd $ALL_CCFRWORK/furax-main
```

Then launch scripts as you see fit
qtass-pyside6 0.9.3
Python version of Qt Advanced Styplesheets Library
Requires Python: <3.14,>=3.12

# qtass-pyside6

**Qt Advanced Stylesheets for PySide 6**

[![PyPI version](https://img.shields.io/pypi/v/qtass-pyside6)](https://pypi.org/project/qtass-pyside6/)
[![Python Version](https://img.shields.io/pypi/pyversions/qtass-pyside6)](https://www.python.org/downloads/)

This is the Python version of the [Qt Advanced Stylesheets Project](https://github.com/githubuser0xFFFF/Qt-Advanced-Stylesheets) for C++.

The library allows runtime color switching for CSS stylesheet themes including
SVG resources and SVG icons. The image below shows switching of accent color
and switching between dark and light theme. Notice how the icons in the left 
sidebar change color when switching between dark and light theme.

![color_switching](https://raw.githubusercontent.com/githubuser0xFFFF/qtass-pyside6/refs/heads/main/doc/CETONI_Elements_Styling.gif)

The main features are:

- runtime switching of CSS colors
- runtime color switching of CSS SVG icons / resources
- runtime color switching of icons loaded via `loadThemeAwareSvgIcon()`
- runtime switching of QPalette colors
- definition of CSS styles that switch the complete application design
- definition of XML color themes that allow switching of theme colors (dark / light)
- switching of individual theme color or switching of accent color
- QML support

---

## 📦 Installation

Install from **PyPI**:

```shell
pip install qtass-pyside6
```
entityagent 0.1.3
Entity Agent: An AI assistant with platform interaction capabilities
Requires Python: >=3.8

# Entity - A Cross-Platform LLM Agent

Entity is a Python-based AI agent designed to interact with your operating system, execute commands, and control programs across Windows, macOS, and Linux.


## Architecture
This agent uses a local Large Language Model (LLM) powered by Ollama. By default, it connects to a locally running Ollama server and uses the default model (e.g., `llama3`). All data and interactions remain private and on your local machine.

The core components are:
- **Agent Logic:** The main Python application that orchestrates tasks.
- **LLM Service:** An Ollama server running a local model (e.g., Llama 3).
- **Platform Interaction:** Modules for interacting with the specific operating system's terminal and applications.


## Getting Started
### Prerequisites

- Python 3.8+
- [Ollama](https://ollama.ai/) installed and running (default: `ollama serve`)
- A downloaded Ollama model (default: `llama3`, run `ollama run llama3` to download)



### Installation
#### From PyPI (recommended)

```bash
pip install entityagent
```

#### From source

```bash
git clone https://github.com/prakashsellathurai/entity
cd entity
pip install .
```


### Running the Agent (Default Ollama)


You can run the agent from the command line (it will use the default Ollama model):


```bash
entity-agent
```
or
```bash
python -m entityAgent.runtime
```
## TODO / Roadmap

- [ ] Allow configuration of LLM model (e.g., choose `llama3`, `mistral`, etc.)
- [ ] Add support for configuring LLM server URL/port
- [ ] Add UI options (CLI, Web, GUI)
- [ ] Add configuration file for user preferences
- [ ] Extend platform interaction capabilities



## Usage

You can interact with the agent in two ways:

1.  **Natural Language:**
    ```
    > Tell me a joke.
    > What is the capital of France?
    ```

2.  **Commands:**
    -   **Execute a shell command:**
        ```
        > run: ls -l
        ```
    -   **List running processes:**
        ```
        > run: list_processes
        ```

## Testing

To run the test suite, execute the following command:

```bash
pytest
```
disjoint-generation 1.0
Exploring the Effects of Disjoint Generation of Synthetic Tabular Data.
Requires Python: >=3.10

<!-- [![Doctests](https://github.com/notna07/disjoint-synthetic-data-generation/actions/workflows/doctests.yml/badge.svg)](https://github.com/notna07/disjoint-synthetic-data-generation/actions/workflows/doctests.yml) -->

# Disjoint Generative Models 

Disjoint Generative Models (DGMs) is a framework for generating synthetic data by distributing the generation of different attributes to different generative models. DGMs unlock mixed model generation, allowing the user to choose ``correct tool for the correct job'' and infers increased privacy by not having a single model that has access to all the data.

The library provides a simple API for generating synthetic data using a variety of generative models and joining strategies. The library has access to a variety of generative model backends namely [SynthCity](https://github.com/vanderschaarlab/synthcity), [DataSynthesizer](https://github.com/DataResponsibly/DataSynthesizer) and [Synthpop](https://www.synthpop.org.uk/get-started.html), but additional backends can be added in the adapters module. Similarly several methods for joining are available for combining the generated data, and more can be added in the joining strategies module.

## Installation

 To install the library, run the following command:

```bash
pip install disjoint-generation
```
One of the generative model backends "synthpop" requires a working R installation on the system. Access is handled through ```subprocess``` to run an ```Rscript``` command, so make sure that the Rscript command works in the terminal.

## Tutorial and Codebooks
 
Below is codebooks that can be used to replicate the results shown in the paper.
| Link | Description | Fig. refs. |
| --- | --- | --- |
| [Tutorial](00_tutorial.ipynb) | A simple tutorial on how to use the library | NA |
| [Codebook 1](01_same_model_partitions.ipynb) | Introductionary experiments, random joining, incresing number of partitions | Fig.2 |
| [Codebook 2](02_validated_joins.ipynb) | High-dimensional dataset example vith validation, correlated partitions study | Fig. 3, 4, 5 |
| [Codebook 3](03_specified_splits.ipynb) | Mixed-model generation and combinatorics | Fig. 6, Tab. 2, 3 |
| [Codebook 4](04_joining_validator.ipynb) | Study of the joining validator model, optimisation and calibration | Fig. 7, 8, 9 |

Additional examples for how to use the library can be seen in the documentation in the source code folder. 

## Requirements
The library requires Python 3.10 (we use version 3.10.12) and the following packages:
- numpy ~= 1.26
- pandas ~= 2.2.3
- scipy ~= 1.12
- scikit-learn ~= 1.5
- synthcity >= 0.2.11
- DataSynthesizer ~= 0.1.13
- pyod >= 2.0

Additonally, the synthpop generative model is accessed through R (we used version 4.1.2), and requires the following R packages:
- synthpop ~= 1.8.0
SDKFeishu 0.0.1
Third-party Python SDK for Feishu Open Platform API
Requires Python: >=3.6

# SDKFeishu - 飞书开放平台Python SDK

一个基于飞书开放平台API，简单易用的非官方Python SDK，提供获取访问令牌、Bitable表格记录CRUD操作、文件上传下载等功能。

## 功能特性
- 获取飞书访问令牌
- 多维表格(bitable)操作：
  - 知识空间管理
  - 表格记录CRUD操作
- 文件上传与下载
- 全面且详细的功能文档

## 环境要求
- Python 3.6+

## 通过 pip 安装
```bash
pip install SDKFeishu
```

## 依赖安装
> 直接通过 pip 安装的 SDKFeishu 无需再手动安装依赖

```bash
pip install requests requests-toolbelt
```

## 快速开始
```python
from SDKFeishu import get_access_token, Bitable

# 1. 获取访问令牌
app_id = "your_app_id"
app_secret = "your_app_secret"
access_token = get_access_token(app_id, app_secret)

# 2. 初始化Bitable客户端
bitable = Bitable(access_token, "your_app_token")

# 3. 使用示例 - 查询表格记录
records = bitable.find_table_record("your_table_id")
print(records)
```

## API参考

### 获取访问令牌
`get_access_token(app_id: str, app_secret: str) -> str`

### Bitable类方法
- `get_wiki_space_list()` - 获取知识空间列表
- `get_wiki_child_space_list(space_id)` - 获取子空间列表
- `get_wiki_space_info(space_id)` - 获取知识空间信息
- `find_table_record(table_id)` - 查询表格记录
- `create_table_record(table_id, fields)` - 创建记录
- `update_table_record(table_id, record_id, fields)` - 更新记录
- `delete_table_record(table_id, record_id)` - 删除记录
- `upload_media(file, file_name, file_size, parent_node)` - 上传文件
- `download_media_by_link(file_token)` - 下载文件

## 错误处理
所有方法在请求失败时会返回包含状态码和错误信息的字符串

## 贡献
欢迎提交 Pull Request 或 Issue 报告问题

## 许可证
MIT
py-trashguard 0.1.3
Safe os.remove alternative with soft delete to .trash/ folder
Requires Python: >=3.7

# py-trashguard

[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/py-trashguard)](https://pypi.org/project/py-trashguard/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)

**Author:** avishek devnath (<avishekdevnath@gmail.com>)  
**License:** MIT License

---

A safe, user-friendly alternative to `os.remove()` that moves files to a `.trash/` folder instead of deleting them permanently. Use it as a Python API or a CLI tool to protect your files from accidental deletion.

---

## Features
- **Soft-delete files:** Move files to a `.trash/` directory instead of permanent removal
- **Restore files:** Bring back files from the trash easily
- **List trashed files:** See what’s in your trash
- **No dependencies:** 100% Python standard library

## Installation

Install from PyPI:
```bash
pip install py-trashguard
```

Or install from source:
```bash
pip install .
```

## Usage

### Python API Example
```python
from pytrashguard import trash, restore, list_trash

# Move a file to trash
t = trash("myfile.txt")
print(f"Trashed: {t}")

# List trashed files
print("In trash:", list_trash())

# Restore a file from trash
r = restore("myfile.txt")
print(f"Restored: {r}")
```

### Command Line Interface Example
Move a file to trash:
```bash
py-trashguard --trash myfile.txt
```

List trashed files:
```bash
py-trashguard --list
```

Restore a file from trash:
```bash
py-trashguard --restore myfile.txt
```

## Project Structure
- `pytrashguard/core.py`: Core logic
- `pytrashguard/cli.py`: CLI entry point
- `pytrashguard/__init__.py`: API exposure
- `pyproject.toml`: Packaging
- `README.md`: Documentation
- `LICENSE`: MIT License

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.