semvec/pypi-packages huggingface dataset:
nicolascalclib 0.1.0
Biblioteca de operações matemáticas básicas
Requires Python: >=3.9

# Nicolas Calc Lib
Biblioteca com as Operações de uma Calculadora em Python

## Operações Suportadas
- soma: Soma
- subs: Subtração
- mult: Multiplicação
- divs: Divisão
- powX: Potência
- pow2: Potência de 2
- raiz: Raiz
- rzqd: Raiz Quadrada
avnst-util 0.1
Avansight Python utility package
Requires Python: >=3.6
Keywords: clinical trials, data analysis, time alignment, TEAE

# Avnst Util

A Python utility package for clinical trial data analysis

## Features

- **Time Alignment**: Tools for aligning and comparing clinical trial event timings
- **TEAE Flag Derivation**: Utilities for determining Treatment Emergent Adverse Events
- **Data Validation**: Functions for checking missing or unknown values in clinical data

## Installation

```bash
pip install avnst_util
```

## Usage

### Time Alignment

```python
from avnst_util.time_alignment import align_time

# Align time for an event
start_time, end_time = align_time(
    date="2023-01-01",
    time="14:30",
    event_name="First Dose"
)
```

### TEAE Flag Derivation

```python
from avnst_util.teae_flag_deriver import derive_teae_flag

# Determine if an AE occurred after first dose
teae_flag = derive_teae_flag(
    first_dose_date="2023-01-01",
    first_dose_time="14:30",
    ae_start_date="2023-01-02",
    ae_start_time="09:00",
    opID="SUBJ001"
)
```

The TEAE flag returns:

- `1`: AE definitely occurred after first dose
- `0`: AE definitely occurred before first dose
- `2`: AE timing overlaps with first dose timing or timing uncertain
- `None`: Unable to determine timing

## Requirements

- Python >= 3.6
- pandas >= 1.0.0

## Development

To set up the development environment:

1. Clone the repository
2. Install development dependencies:

```bash
pip install -e .
```

## Contact

- Author: Eric Liu
- Email: txender4@gmail.com
xldparser 0.1.4
Parse the X Lossless Decoder a.k.a. XLD app log files
Requires Python: >=3.12.6

# python-xldparser

![GitHub branch check runs](https://img.shields.io/github/check-runs/rinsuki/python-xldparser/main)
![PyPI - Version](https://img.shields.io/pypi/v/xldparser)
![PyPI - License](https://img.shields.io/pypi/l/xldparser)

Parse the [X Lossless Decoder](https://tmkk.undo.jp/xld/) (a.k.a. XLD) log file.

Combine this library with another library like [mutagen](https://github.com/quodlibet/mutagen), you can easily add ripping status (e.g. AccurateRip status, failing sector information) to your ripped audio file, as a metadata.
torin 0.1.0
A lightweight logging and tracking utility
Requires Python: >=3.6

# Torin

A lightweight Python package for logging and tracking metrics.

## Installation

```bash
pip install torin
```

## Usage

```python
import torin

# Initialize a run
run = torin.init(project="my-project", name="experiment-1")

# Log metrics
torin.log({"accuracy": 0.95, "loss": 0.05})

# Finish the run
torin.finish()
```

## API Reference

### `torin.init()`

Initializes a run and connects to the backend service.

```python
run = torin.init(
    project="my-project",
    entity="my-team",
    name="experiment-1",
    config_dict={"learning_rate": 0.01}
)
```

### `torin.log()`

Logs metrics or other data to the current run.

```python
torin.log(
    {"accuracy": 0.95, "loss": 0.05},
    step=10,
    commit=True
)
```

### `torin.finish()`

Flushes all pending logs and finishes the run.

```python
torin.finish(exit_code=0)
```

### `torin.flush()`

Explicitly flushes pending logs.

```python
torin.flush(timeout=30)
```

## License

[MIT License](LICENSE)
thelethe 0.0.1
AI models with adaptive memory management and strategic forgetting, inspired by Greek mythology and neuroscience.
Requires Python: <3.14,>=3.9

# theRiverLethe
AI models with adaptive memory management and strategic forgetting, inspired by Greek mythology and neuroscience.

<img src="./docs/image/banner.jpeg" width="100%">


## Academic History of Titans Architecture
- **Background**: Prior to Titans Architecture, significant research was conducted related to test-time model adaptation and fast-weighted methods, primarily building on two key concepts:
  > Self-supervised Learning and Meta Learning formed the foundation for these approaches.
- **2017-03-09** [Model-Agnostic Meta-Learning (MAML)](https://arxiv.org/abs/1703.03400): Pioneered fast adaptation to new tasks with minimal training examples, establishing core principles for adaptive models.
- **2019-09-29** [Test-time Training](https://arxiv.org/abs/1909.13231): Advanced the field by introducing methods for model adaptation during inference time without requiring complete retraining.
- **2024-07-05** [TTT-Linear/MLP](https://arxiv.org/abs/2407.04620): Introduced as a Self-Attention alternative for Transformers, enabling automatic retention of input sequences by using Self-supervised learning.
- **2024-12-31** [Titans Architecture](https://arxiv.org/abs/2501.00663): Established a novel memory-based architecture combining Transformer's short-term memory capabilities (Self-Attention) with MLP-based long-term memory, significantly improving performance on extended sequential tasks.
- **2025-MM-DD** [Atlas Model]()


## Overview
### Titans Origin
- Titans introduced a new architecture family which consisted of:
  - Core Self-Attention (Short-term Memory, In-context learning)
  - Contextual Memory (Long-term Memory)
  - Persistent Memory (Fixed Memory)

#### Memory as a Context (MAC)

#### Memory as a Gate (MAG)

#### Memory as a Layer (MAL)


### Atlas Model
- Atlas is a Titan in Greek mythology who is assigned the role of supporting the celestial sphere.

<img src="./docs/image/atlas.png" width="50%">

- Atlas Model proposes a combination of cognitive-scientific memory components.
  - Semantic Memory (Retrospective, Long-term Memory)
  - Episodic Memory (Retrospective, Long-term Memory)
  - Intentional Memory (Prospective, Long-term Memory)
  - Active Cognitive State (Working/Operational, Short-term Memory)

<img src="./docs/image/atlas_memory.png" width="50%">
fixr 0.2.1
Python bindings to xrif, the extreme reordered image format
Requires Python: >=3.10

# fiXr

Open xrif archives from Python directly using the [xrif](https://github.com/jaredmales/xrif) library.

## Example

```python
from fixr import xrif2numpy
import logging
logging.basicConfig(level='DEBUG')
fh = open('example_data/camwfs_20240315225750994842000.xrif', 'rb')
data = xrif2numpy(fh)
```
which will print something like

```
DEBUG:fixr:xrif compression details:
  difference method:  previous
  reorder method:     bytepack
  compression method: LZ4
    LZ4 acceleration: 1
  dimensions:         120 x 120 x 1 x 512
  raw size:           14745600 bytes
  encoded size:       7446095 bytes
  ratio:              0.505
```

The file ends with the timing information for the frames, stored as a separate xrif section:

```python
timings = xrif2numpy(fh)
```

Each row contains the frame index, acquisition timestamp (as integer seconds and integer nanoseconds), and write timestamp (again as two integers).

```
>>> timings.shape
(787, 1, 1, 5)
```

For an example that uses the C xrif lib more directly, see [minimal_ex.py](https://github.com/joseph-long/fixr/blob/main/minimal_ex.py).

## Changelog

### 0.2.1

 - Fix macOS-ism (using `.dylib` instead of `.so` to load library)
 - Declare NumPy >= 2.0 dependency
 - Update various bits of CI machinery

### 0.2.0

 - Add missing typecodes ([#1](https://github.com/joseph-long/fixr/issues/1), [#2](https://github.com/joseph-long/fixr/pull/2))

### 0.1.0

 - Initial release
retentionengine 0.0.1
A simple adapter implementation to transform pretrained Transformer-family models into the Titans architecture.
Requires Python: <3.14,>=3.9

# RetentionEngine
A simple adapter implementation to transform pretrained Transformer-family models into the Titans architecture.

## Experiments Setup
### Exp 1: Comparison with Base Models [3B]
#### Baseline
- Titans 4B (Gemma3 4B IT)
- Llama3.2 3B Instruct
- Qwen3 4B
- Gemma3 4B IT
- RAG + Llama3.2 3B Instruct
- RAG + Qwen3 4B
- RAG + Gemma3 4B IT

#### Suggested
- Atlas-L 3B (Llama3.2 3B Instruct)
- Atlas-Q 4B (Qwen3 4B)
- Atlas-G 4B (Gemma3 4B IT)

### Exp 2: Comparison with Base Models [8B]
#### Baseline
- Titans 9B (Gemma2 9B IT)
- Llama3.1 8B Instruct
- Qwen3 8B
- Gemma3 9B IT
- RAG + Llama3.1 8B Instruct
- RAG + Qwen3 8B
- RAG + Gemma3 9B IT

#### Suggested
- Atlas-L 8B (Llama3.1 8B Instruct)
- Atlas-Q 8B (Qwen3 8B)
- Atlas-G 9B (Gemma3 9B IT)

### Exp 3: Comparison with Recurrent Models [8B]
#### Baseline
- Titans 9B (Gemma2 9B IT)
- Mamba2 8B
- RWKV6 7B

#### Suggested
- Atlas-L 3B (Llama3.2 3B Instruct)
- Atlas-Q 4B (Qwen3 4B)
- Atlas-G 4B (Gemma3 4B IT)
- Atlas-L 8B (Llama3.1 8B Instruct)
- Atlas-Q 8B (Qwen3 8B)
- Atlas-G 9B (Gemma3 9B IT)


## Build
```bash
git clone https://github.com/retentionlabs/RetentionEngine.git
cd RetentionEngine
uv pip sync
```

## Usage
- See `usage.ipynb` for usage examples.

## Deploy
```bash
rm -rf dist/
rm -rf build/
rm -rf *.egg-info

python -m pip install --upgrade pip
pip install flit
python -m flit build

echo "Uploading..."
python -m flit publish

echo "Deployment complete!"
```