semvec/pypi-packages huggingface dataset:
PPlotly 0.0.4
Wrapper project of plotly.py, extra functionalities for scientific plots
Requires Python: >=3.8

## PPlotly.py

It is a wrapper around `plotly.py`. Graph styles and functionalities are added to get scientific plots. 

### Quickstart

`pip install pplotly`

```python
import pplotly as pp
fig = pp.Figure()
fig = fig.add_trace(pp.Scatter(x=["a", "b", "c"], y=[1, 3, 2]))
fig.show()
```
All the `plotly` functionalities are available to use under `pplotly.plotly`

### Examples

#### Error plot
```python
import pplotly as pp
import numpy as np

fig = pp.make_errorplot(
    xaxis_title="X-Title",
    yaxis1_title="Y-Title [Unit]",
    yaxis2_title="Error [Unit]"
)

x_data = [1, 2, 3]
y1_data = [2.1, 2.2, 3.1]
y2_data = [2.15, 2.21, 3.05]

fig.add_trace(
    pp.Scatter(x=x_data, y=y1_data, name="Plot 1")
)

fig.add_trace(
    pp.Scatter(x=x_data, y=y2_data, name="Plot 2")
)

error = [abs(p2-p1) for p1, p2 in zip(y1_data, y2_data)]
rmse = np.sqrt(np.mean(np.array(error)**2))
fig.add_trace(pp.Scatter(x=x_data, y=error, name=f"Abs Error: RMSE = {round(rmse, 3)}"), row=2, col=1)
fig.show()
```

## Developer options

```bash
git clone 
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
pre-commit install
```
TCFile 2024.11.0
Python package for handling TCF data. It works with Tomcube data
Requires Python: <4,>=3.7

# TCFile python package

A basic image processing tool of tomocube data.

## Installation

```bash
pip install TCFile
```

## Use case

```python

from TCFile import TCFile

tcfile = TCFile('test.TCF','3D') # ready for return 3D RI images
print(f"number of snapshots : {len(tcfile)}")

## Usage 1: handling each snapshots (numpy array)
data = tcfile[0]
print(f"shape of data : {data.shape}")
# or
for data in tcfile:
    # do some operations on the data ...
    pass

## Usage 2: handling fluorescence array
tcfile_fl = TCFile('test.TCF','3DFL')
fl_data = tcfile_fl[0]

## Usage 2: handling dask array
data = tcfile.asdask() # (T, Z, Y, X) array

```

## Limitation

It does not support TCF writer due to the difficulty of configuring metadata and interoperability with commercial Tomocube software.

## TODO
- [ ] rigorous tests
- [ ] TCFile converter

Any suggestions and comments are welcome!

## Test

```bash
# install this package in editable mode
git clone https://github.com/ehgus/TCFile.git
cd TCFile
pip install -e .
# execute pytest
pytest
```
dynamic-genetic-algo 3.0.0
A genetic algorithm library
Requires Python: >=3.11

# Genetic Algorithm for Flexible Data Handling

A Python library that leverages genetic algorithms to generate optimized queries for handling data flexibly without dropping rows. This approach enables selective row exclusion per query, bypassing the need for imputation or deletion, and supports high-volume data processing through parallelism.

## Features

- Generates custom queries to ignore specific rows based on query-specific criteria.
- Supports high-volume data processing with parallel computation.
- Dynamically calculates feature-specific min/max values for optimized filtering.
- Enables binary classification filtering and calculates the percentage of 1s.

## Workflow

1. **Load and Clean Data**:

   - Load data and apply minimal cleaning (e.g., drop `inf` values or other outliers that could disrupt quintile calculations).

2. **Set Parameters**:

   - Define parameters that control the algorithm's behavior and query generation.

3. **Dynamic Feature Computation**:

   - Compute min/max values and deltas dynamically for each feature to enhance query specificity.

4. **Generate Feature-Specific Combinations**:

   - Produce min/max combinations for each feature based on unique criteria.

5. **Filter Data**:

   - Filter CSVs using generated criteria, calculating the percentage of 1s for binary classification tasks (if applicable).

6. **Genetic Algorithm Optimization**:
   - Carry over the fittest combinations to the next generation, introducing new entries at a defined rate for continuous improvement.

## Installation

Install the package via pip:

```bash
pip install dynamic_genetic_algo

from dynamic_genetic_algo import GeneticAlgorithm, GeneticParams

# Define the genetic parameters
genetic_params = GeneticParams(
    population_size=200,
    elite_size=0.1,
    mutation_rate=0.6,
    generations=1000,
    min_size_ratio=0.005,  # Percent of dataset that must be retained to avoid anomalies
    average_column="Example Target",
    categorical_columns=id_dict,  # Dictionary where key is column name and value is list of possible categories
    super_elite=20  # Extra privileges for the top elite
)

# Initialize and run the genetic algorithm
if __name__ == "__main__":
    genetic_algo = GeneticAlgorithm(
        training_data=combined_df,
        target="Target Over 5",
        columns_to_drop=[
            "Sample Column 1",
            "Sample Column 2",
            "Target"  # Exclude target column from queries
        ],
        genetic_params=genetic_params,
    )
    genetic_algo.run()
```
journ-app 1.0.7
A CLI Journaling that honors your text editor of choice
Requires Python: >=3.6

## Why journ?
journ is a terminal-based journaling app meant to keep you in your terminal. As I've progressed in my development journey, I realized that developers want to stay in their editor/IDE of choice as long as possible. journ is meant to work with your default editor of choice so that you can go from journaling to development all from the ease of the terminal. All while helping you stay accountabile with a daily word goal and streak tracker.

## About the Project
journ started as a project to mimic much of the functionality of the website 750words.com but to make the data local for the users instead of in a cloud. It started to feel weird to me with how much personal stuff I was journaling with on a site with a backend that was not in my control.

Since conception of the project, I've deviated a bit from the clone of 750words.com goal and am dedicating myself to a "fully featured" journaling app in the terminal. The core of journ is that I don't want to take your default text editor from you. People who like to do things in their terminal have their editor of choice (I use neovim btw) and so journ defaults to whatever you have it set up as.

It's helpful to have a word counter in your text editor of choice, but journ will take care of that for you if not (just not as elegantly)


The Completion of below will make journ official v1
### To Do List

- [X] Fully implement daily tmp file for editing
- [x] User login
  - [x] Prevent journaling to anyone logged out
  - [x] Journal Session logging
  - [x] User goals fully implemented
  - [x] Storage of data based on User Login
  - [x] sqlite database uses stored user idea
    - [x] User can update their goals
- [x] Journaling streak
- [x] Implement default to user defined text editor
- [x] Make password optional
- [x] Add current journ data (word count mostly)

### Bug List
- [x] Changing login system created error when user says they've logged in if db is empty
- [x] System allows for overwriting of user names
- [x] Current implementation creates difficult loop if register process starts and user isn't sure they want the selected login, not sure how to fix right now. Will have to replace the recursive calls with while loops.
- [x] journal sessions are not currently tied to user/any user can access any other users' current journ
- [x] todays_journ breaks when user hasn't journaled yet
- [x] Streak incremented multiple times a day 
- [x] Registration followed by journ breaks system
- [x] other users can still access another's daily journ