semvec/pypi-packages huggingface dataset:
he5py 1.0.6
Utilities for working with the HDF-EOS-5 remote sensing data format

# he5py

utilities for working with the HDF-EOS-5 remote sensing data format

[Gregory H. Halverson](https://github.com/gregory-halverson-jpl) (they/them)<br>
[gregory.h.halverson@jpl.nasa.gov](mailto:gregory.h.halverson@jpl.nasa.gov)<br>
NASA Jet Propulsion Laboratory 329G

## Prerequisites

This package requires the HDFEOS5 and xtensor libraries, which can be installed using mamba.
```
mamba install hdfeos5 pykdtree xtensor xtensor-python
```

## Installation

Install this package using pip.
```
pip install he5py
```
simplepidcontroller 1.0.0
A simple PID controller in Python
Requires Python: >=2.7

# PID Controller: How to use

## Step 1: Importing

```python
from simplepidcontroller import PID
```

You have now imported the PID Controller

## Step 2: Make a system
We will use a first order process system to simulate a real life application
```python
class Process:
    def __init__(self, k=1, tau=1):
        self.k = k
        self.tau = tau
        self.y = 0
    def update(self, u, dt):
        self.y += (self.k * (u - self.y) / self.tau) * dt
        return self.y
process = Process()
```
It is not the most complicated but it will work

## Step 3: Defining constants
Start by making the pid controller. First, define the set point and plug it in to a new PID object
```python
set_point = 100
pid = PID(set_point)
```
This package supports two types of the PID controller equation.

The parallel form,

$$u(t) = K_p e(t) + K_i \int e(t) dt + K_d \frac{de}{dt}$$

where...  
$K_p$, $K_i$, and $K_d$ are all constants,  
and $K_pe(t)$ is the proportional action,  
$K_i \int e(t) dt$ is the integral action,  
and $K_d \frac{de}{dt}$ is the derivative action

and the ideal form,

$$u(t) = K_p \bigg(e(t) + \frac{1}{\tau_i} \int e(t) dt + \tau_d \frac{de(t)}{dt}\bigg)$$

where...  
$K_p$ is the proportional gain,  
$\tau_i$ and $\tau_d$ are integral and derivative time constants respectively  
$K_pe(t)$ is the proportional action,  
$K_i \int e(t) dt$ is the integral action,  
and $K_d \frac{de}{dt}$ is the derivative action

$t$ is the time and $e(t)$ and $u(t)$ are the error and output at time $t$ respectively in both

You can input the parallel constants with
```python
pid.parallel_constants = kp, ki, kd
```
and the ideal constants with
```python
pid.ideal_constants = kp, ti, td
```

## Step 4: Using the Controller
You can use a simple ```for``` loop to use the controller
```python
import time
INTERVAL = 0.1
y = process.update(0, INTERVAL)
for _ in range(150):  # Or the amount of times you want to use the controller
    time.sleep(INTERVAL)
    u = pid.compute(y, INTERVAL)  # Compute the value
    process.update(u, INTERVAL)  # Use the value to update system
```

This will be sufficient to make sure the value reaches the set point

You can also turn on derivative filtering with the filter time constant and filter flag parameters
```python
pid = PID(set_point, tf=filter_time_constant)
...
pid.compute(y, INTERVAL, filter_derivative=True)
```

or anti-windup with the minimum and maximum bounds for the output and the anti-windup flag parameters
```python
pid = PID(set_point, u_min=minimum, u_max=maximum)
...
pid.compute(y, INTERVAL, anti_windup=True)
```

um thats it hope u liked
sherlock-lit 0.1.4
Sherlock-lit helps you get everything an Abstract hides with a fast technical description card (Research questions, contribution, possible future works) of an NLP paper before reading it.
Requires Python: >=3.11

# Sherlock-lit

Sherlock-lit is a Python package (part of the tools used in haut platform) designed to process NLP research papers (Later, on more general papers) and generate precise descriptions of the papers in markdown (MD) card format. It streamlines understanding and documentation of research papers, making it an invaluable tool for researchers, students, and developers in NLP field to discover easily the contributions and research questions researchers tackle without being lost in papers or being doubtful after reading the abstract.

---

## Features

- **Markdown Card Generation**: Automatically generates concise and precise descriptions of NLP papers in markdown format.
- **Efficient Processing**: Really fast on CPUs and also can be further improved with GPU.
- **Small Size**: less than **70 MB**.
- **First-Time Setup**: The first run may be slower due to setup, but subsequent runs are significantly faster.
- **Simple Command-Line Interface**: Process papers by simply providing the path to a PDF file or a folder containing PDFs files.

---

## Installation

Sherlock is currently available for installation directly from GitHub. To install, run:

```bash
pip install sherlock-lit 
```

---

## Usage

Once installed, you can process a research paper by running:

```bash
sherlock_lit file_path.pdf
```

Replace `file_path.pdf` with the path to the research paper you want to process. The markdown card will be generated and saved in the output directory. 

---

## Example Workflow

1. Install sherlock-lit from PypI.
2. Run `sherlock_lit` on a PDF file:

   ```bash
   sherlock_lit example_paper.pdf
   ```

3. Retrieve the generated markdown card from the output directory (card-papers folder located in the current directory).

---

## Contributions

Contributions are welcome! I will be writing the contribution guidelines very soon.

---

## Future Plans

- Optimize processing speed further.
- Improve parsing of papers.
- Add support for more advanced GPU and multi-threaded processing.
- Expand compatibility for additional research paper formats.

---

## License

Sherlock-lit is licensed under the [MIT License](LICENSE).

---