semvec/pypi-packages huggingface dataset:
pypnnomenclature 1.6.5
Python lib related to nomenclatures

# Nomenclature-api-module

[![pytest](https://github.com/PnX-SI/Nomenclature-api-module/actions/workflows/pytest.yml/badge.svg)](https://github.com/PnX-SI/Nomenclature-api-module/actions/workflows/pytest.yml)
[![codecov](https://codecov.io/gh/PnX-SI/Nomenclature-api-module/branch/master/graph/badge.svg?token=KGZRGXFWCK)](https://codecov.io/gh/PnX-SI/Nomenclature-api-module)

Flask (Python) module for Nomenclature API.

It is used in [GeoNature](https://github.com/PnX-SI/GeoNature) but can also be used as a standalone API service to manage and returns various nomenclatures with their hierarchy. 

Can be used as a standalone module or as git submodule. 

# Database

`bib_nomenclatures_types` contains nomenclatures types list.

id_type | mnemonique | label_fr | label_en | definition_fr | definition_en | source | statut | meta_create_date | meta_update_date
------- | ---------- | -------- | -------- | ------------- | ------------- | ------ | ------ | ---------------- | ----------------
10 | TYP_DENBR | Type de dénombrement | Counting type | Nomenclature des types de dénombrement possibles (comptage, estimation...) | Possible counting types (count, estimation...) | SINP | Validated | 2014-01-22 00:00:00 | 2015-12-16 00:00:00 | 

`t_nomenclatures` contains all nomenclatures with their type, their parent (broader) and their hierarchy.

id_nomenclature | id_type | cd_nomenclature | mnemonique | label_fr | definition_fr | source | statut | id_broader | hierarchy | meta_create_date | meta_update_date | activ
------- | ---------- | -------- | -------- | -------- | --------- | ------ | ------ | -------- | ------ | ------ | ------ | ------
10 | 10 | 8 | Têtard | Têtard | Larve de batracien | SINP | Validé | 2 | 010.008 | 2015-07-29 00:00:00 | 2015-10-09 00:00:00 | true

## Database usage

Get all nomenclatures of a type :

```
SELECT *
FROM nomenclatures.t_nomenclatures n
WHERE n.id_type = 100 AND n.active = true
```

Get all nomenclatures of a rank of a type :

```
SELECT *
FROM JAIPASCAPTE
```

# Usage

# API

* Récupération des termes d'une nomenclature à partir de l'identifiant : ```/nomenclature/6[?regne=Animalia[&group2_inpn=Bivalves]]```
 DEPRECIE

* Récupération des termes d'une nomenclature à partir du code mnemonique :```/nomenclature/STADE_VIE[?regne=Animalia[&group2_inpn=Bivalves]]```
* Récupération des termes d'un ensemble de nomenclature :
  * ```/nomenclatures?id_type=22&id_type=6[&regne=Animalia[&group2_inpn=Bivalves]]```  DEPRECIE
  * ```/nomenclatures?code_type=STADE_VIE&code_type=REF_HAB[&regne=Animalia[&group2_inpn=Bivalves]]```


# Interface d'administration des données

 * Accessible via l'url /nomenclatures/admin

# Installation

Cloner repository and then launch in the folder:

```
python setup.py install
```
hey-py 0.1.3
A command-line tool to interact with DuckDuckGo Chat API from your terminal
Requires Python: >=3.8

# hey-py

Python port of [hey](https://github.com/b1ek/hey), a command-line interface for DuckDuckGo's AI Chat with enhanced features.

## ✨ Features

### 🤖 AI Models
- Multiple model support:
  - Claude 3 Haiku (default)
  - GPT-4o Mini
  - Mistral 8x7B
  - Llama 3.1 70B
- Customizable system prompts

### 💬 Chat Experience
- Rich markdown support in responses
- Conversation memory with auto-expiry
  - Stores last 10 messages
  - 24-hour automatic expiration
  - Manual clearing with `hey --clear`
  - Persistent storage in `~/.cache/hey`
- Real-time streaming responses

### 🛠️ Configuration
- Easy configuration via `hey config`
- HTTP and SOCKS proxy support
- Persistent settings in `~/.config/hey`
- Verbose mode for debugging

## 🚀 Installation

```bash
pip install hey-py
```

## 📖 Usage

### Basic Usage
```bash
# Ask a question
hey What is Python?

# Clear conversation history
hey --clear

# Configure settings
hey config
```

### Configuration Options
- Select AI model
- Set system prompt
- Configure proxy settings
- Accept Terms of Service

### Environment Variables
- `HEY_CONFIG_PATH`: Custom config directory (default: `~/.config/hey`)
- `HEY_CACHE_PATH`: Custom cache directory (default: `~/.cache/hey`)
- `HEY_CONFIG_FILENAME`: Custom config filename (default: `conf.toml`)
- `HEY_CACHE_FILENAME`: Custom cache filename (default: `messages.json`)

## 📝 License
GPLv3
laserfields 0.4.2
Python library for describing time-dependent laserfields by Johannes Feist.
Requires Python: >=3.7

# laserfields

`laserfields` is a python library to describe the time-dependent electric fields
of a laser pulse, and can be installed with `pip install laserfields` or `conda
-c conda-forge install laserfields`. It implements the same pulse shapes and
most of the features of the [laserfields
library](https://github.com/jfeist/laserfields) written in Fortran (and as the
Julia variant [LaserFields.jl](https://github.com/jfeist/LaserFields.jl)),
please see the documentation of that library for the parameter meanings,
conventions used, etc. In particular, the "main" function
`make_laserfield(**kwargs...)` accepts the same parameters as the Fortran
library parameter files as keyword arguments, and returns an instance of a
subtype of the base class `LaserField` depending on the parameters. E.g., to
create a Gaussian pulse with a duration (defined as the FWHM of the intensity)
of 6 fs, a wavelength of 800 nm, a peak intensity of 1e14 W/cm^2, and with the
peak at time t=7fs, one should call
```python
lf = make_laserfield(form="gaussianI", is_vecpot=true, lambda_nm=800,
                      intensity_Wcm2=1e16, duration_as=6000, peak_time_as=7000)
```

Given a `LaserField` instance `lf`, the functions `lf.E(t)`,
`lf.E_fourier(ω)`, `lf.A(t)`, and `lf.A_fourier(ω)` can be used to obtain,
respectively, the electric field as a function of time, its Fourier transform
(implemented for most pulse shapes), the vector potential as a function of time,
and its Fourier transform. Calling the instance as a function, `lf(t)` returns
the electric field, i.e., is equivalent to `lf.E(t)`. The notebooks in the
`examples` folder show some ways to use the library, including how to define a
set of fields through a YAML configuration file.

In addition to the pulses described by each `LaserField` instance, the library
also implements a `LaserFieldCollection` class that can be used to combine
multiple fields into a single effective one (i.e., the sum of the individual
ones). It is also a `LaserField` instance and supports much of the same
interface. Note that some of the parameters it contains are just "best-effort"
values and may not be fully meaningful for the combined field - e.g., for the
carrier frequency `lf.ω0`, it returns the highest value in the collection, to
support use cases where this is used to define maximum time step in a numerical
propagation, or the maximum frequency evaluated in a Fourier transform.

The "effective" duration of the pulse for n-photon processes can be obtained as
`lf.Teff(n_photon)`, which is the integral over the pulse intensity envelope to
the n-th power (i.e., electric field envelope to the (2n)th power)
over the pulse, see, e.g., https://doi.org/10.1103/PhysRevA.77.043420 (Eq. 14).