semvec/pypi-packages huggingface dataset:
srtlst 0.2.0
a simple, generically type-annotated, sorted list
License: MIT
Requires Python: >=3.8,<4.0
Keywords: sorted,list,simple,container,sorting,bisect,typed,mypy

# srtlst

_a simple, generically type-annotated, sorted list_

![python_version](https://img.shields.io/pypi/pyversions/srtlst)
[![mypy_checked](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)

### usage

Create a sorted list like this:

```python
>>> from srtlst import SortedList
>>> s = SortedList([5, 3, 1])
>>> print(s)
[1, 3, 5]
```

A `SortedList` mimics a regular `list` in most ways, but remains sorted:

```python
>>> s = SortedList([5, 3, 1])
>>> s.extend([6, 2, 4])
>>> print(s)
[1, 2, 3, 4, 5, 6]
```

You can use `add()` instead of `insert()` or `append()`:

```python
>>> s = SortedList([5, 3, 1])
>>> s.add(3)
>>> s.add(2)
>>> print(s)
[1, 2, 3, 3, 5]
```

If you need your data to be sorted in descending order use the optional `reverse` parameter:

```python
>>> s = SortedList([1, 2, 3], reverse=True)
>>> s.add(4)
>>> print(s)
[4, 3, 2, 1]
```

If your data is not inherently sortable, or you want to sort it in a non-default way, you can use `SortedListByKey`
and supply a function to sort it (just like with `sorted()`):

```python
>>> from srtlst import SortedListByKey
>>> my_function = lambda x: x * (-1) ** x
>>> s = SortedListByKey([1, 2, 3, 4], key=my_function)
>>> print(s)
[3, 1, 2, 4]
```

`SortedListByKey` behaves like a `SortedList` in all other ways, and indeed inherits from it.
However, when type checking, a `SortedList` only accepts values for which a less-than (`<`) method is defined (`__lt__()`).

`SortedListByKey` accepts any type of object, as long as an appropriate key function is provided.
The key function must return comparable values for the items in the list.

### installation

No surprises here:

```shell
$ pip install srtlst
```

### type checking

`SortedList` and `SortedListByKey` are type-hinted according to [PEP 484](https://peps.python.org/pep-0484/)
and the `srtlst` library is itself checked using `mypy --strict`.

Type hints for both containers can be provided using type arguments, just like with `list` and other containers:

```python
s: SortedList[int] = SortedList([3, 2, 1])
```

### performance

This library aims to provide a simple sorted list without any dependencies which is ready for use.
Some of the list operations are reimplemented to take advantage of the list's sortedness using Python's standard `bisect` library.

This library should suit your needs if you just want to keep stuff sorted, without having to implement the bookkeeping yourself.
However, if your sorting needs arise from the need for performance, you should also consider this library:
[sortedcontainers](https://grantjenks.com/docs/sortedcontainers/).  

### documentation

Documentation is work in progress. For now the Python's built-in help function can be of service:

```python
>>> from srtlst import SortedList
>>> help(SortedList)
```
HawkesPyLib 0.2.2
Python library for simulation and inference of Hawkes processes
License: MIT
Requires Python: >=3.8
Keywords: hawkes,hawkes-process,point-process

![Tests](https://github.com/Simbold/HawkesPyLib/actions/workflows/tests.yml/badge.svg?branch=master)
![Build](https://github.com/Simbold/HawkesPyLib/actions/workflows/build_master.yml/badge.svg?branch=master)
[![PyPI package](https://img.shields.io/pypi/v/HawkesPyLib?color=green&label=pypi%20package)](https://pypi.org/project/HawkesPyLib/)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/HawkesPyLib)](https://www.python.org/downloads/)
[![License: MIT](https://img.shields.io/pypi/l/HawkesPyLib?color=blue)](https://opensource.org/licenses/MIT)

# HawkesPyLib
A simple Python Package for simulation and inference of Hawkes processes. The library is currently under active development. More methods and functionality will be introduced shortly.

## Installation

    $ pip install HawkesPyLib

## Documentation

A detailed description of the package can be found in the [documentation](https://simbold.github.io/HawkesPyLib/).

## Description
The library allows for simulation and fitting of Hawkes processes. Hawkes processes are self-exciting point processes and can be used to model or analyse event arrivals. Hawkes processes can be defined in terms of the conditional intensity function:

$$ \lambda(t) = \mu + \sum_{t_i < t} g(t-t_i) $$

where $\mu$ is a constant background intensity and the memory kernel function $g(t)$ specifies how past event arrivals influence the current state of the process. 

The following Hawkes process models are currently available:
- Univariate Hawkes process with single exponential memory kernel
- Univariate Hawkes process with P-sum exponential memory kernel
- Univariate Hawkes process with approximate power-law memory kernel
- Univariate Hawkes process with approximate power-law memory kernel with smooth cutoff
- Homogenous Poisson process

For each of the models there is a simulator class for generating Hawkes process samples using Ogata's thining algorithm.
The estimator class allows for maximum likelihood estimation of the model as well as the calculation of the corresponding compensator, and evaluation of the conditional intensity function.

A quick example of simulating and estimating Hawkes processes can be found in the Examples folder.

The core simulation and estimation algorithms are optimized for speed
by recursive calculation of the model and further accelerated by
[numba's](https://numba.pydata.org/) JIT compiler.

## License

HawkesPyLib is distributed under the terms of the [MIT](https://opensource.org/licenses/MIT) license.
lambda-layer-manager 0.1.0
Automatic Lambda Layer Manager
License: MIT
Requires Python: >=3.11,<4.0

# Lambda Layer Manager

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v1.json)](https://github.com/charliermarsh/ruff)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square)](https://github.com/psf/black)
[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat-square&labelColor=ef8336)](https://pycqa.github.io/isort/)

## Overview

Automatically build and deploy AWS Lambda layer.

**Config:**
```json
{
  "layers": [
    {
      "name": "<name_of_the_layer>",
      "requirements": "<path_to_requirements_file>",
      "config": {
        "description": "<description>",
        "compatible_runtimes": ["<python3.10>"],
        "compatible_architectures": ["<x86_64>"]
      }
    }
  ]
}
```

An example configuration can be found in the `./example` directory.

## Quickstart

Run the *Lambda Layer Manager* (*llm*) with the following command:
```bash
llm <path/to/config_file>
```

## Contribution

Install the dependencies:
```bash
poetry install
```

Enable the *pre-commit* hooks:
```bash
pre-commit install
```

## License

This project is licensed under the MIT license.