semvec/pypi-packages huggingface dataset:
tmark 0.0.3
Time marking package in code.
Requires Python: >=3.10
Keywords: time marks plot

# Description
This module is designed for setting time stamps in code, convenient to use in cycles.

# Installing
```Shell
pip install tmark
```

or

```Shell
pip install git+https://github.com/OnisOris/tmark
```

# Example

```python
import tmark as tm
import time

tracker = tm.LatencyTracker()

# Simulation of a cycle with multiple tags in one iteration
for i in range(12):
    tracker.start("operation_1")
    time.sleep(0.1 + i * 0.02)  # Simulation of first operation
    tracker.stop("operation_1")

    tracker.start("operation_2")
    time.sleep(0.2 + i * 0.03)  # Simulation of the second operation
    tracker.stop("operation_2")

    tracker.start("operation_3")
    time.sleep(0.15 + i * 0.01)  # Simulation of the third operation
    tracker.stop("operation_3")

# Graph from object data
tracker.plot(statistic=True)

# Save to csv file
tracker.save_to_csv()

# Reading from csv file and plotting
tracker.plot_from_csv()
```

![Graphic](https://github.com/OnisOris/tmark/blob/main/img.png)

# Possible errors
/.../.venv/lib/python3.10/site-packages/tmark/latency_tracker.py:88: UserWarning: FigureCanvasAgg is non-interactive,
and thus cannot be shown plt.show()

## Solution:

pip install PyQt6
estndv 0.0.3
Learned sample-based estimator for number of distinct values.
Requires Python: >=3.6

### Learned NDV estimator
Learned model to estimate number of distinct values (NDV) of a population using a small sample. The model approximates the maximum likelihood estimation of NDV, which is difficult to obtain analytically.
See our VLDB 2022 paper [Learning to be a Statistician: Learned Estimator for Number of Distinct Values](https://vldb.org/pvldb/vol15/p272-wu.pdf) for more details.

### How to use
1. Install the package
   
    `pip install estndv`

2. Import and create an instance

```python
   from estndv import ndvEstimator
   estimator = ndvEstimator()
```

4. Assume your sample is S=[1,1,1,3,5,5,12] and the population size is N=100000. You can estimate population ndv by:

    `ndv = estimator.sample_predict(S=[1,1,1,3,5,5,12], N=100000)`
   
5. If you have the sample profile e.g. f=[2,1,1], you can estimate population NDV by:
   
    `ndv = estimator.profile_predict(f=[2,1,1], N=100000)`

6. If you have multiple samples/profiles from multiple populations, you can estimate population NDV for all of them in a batch by method `estimator.sample_predict_batch()` or `estimator.profile_predict_batch()`.



### How to train the ndv estimator
You can directly use our package on PyPI for your datasets, as the pre-trained model is agnostic to any workloads. However, if you want to train the model from scratch anyway, do the following:
1. Go to the model_training folder
    `cd model_training`

2. Install requirements
   
    `pip install requirements.txt`
   
3. Generate training data. (This uses a lot of memory.)
   
    `python training_data_generation.py`
   
4. Train model
   
    `python model_training.py`
5. Save trained pytorch model parameters to numpy, this generates a file model_paras.npy

    `python torch2npy.py`

6. Test with your model parameters by specifying a path to your model_paras.npy

   `estimator = ndvEstimator(para_path=your path to model_paras.npy)`

### Citation
If you use our work or found it useful, please cite our paper:
```
@article{wu2022learning,
   author = {Wu, Renzhi and Ding, Bolin and Chu, Xu and Wei, Zhewei and Dai, Xiening and Guan, Tao and Zhou, Jingren},
   title = {Learning to Be a Statistician: Learned Estimator for Number of Distinct Values},
   year = {2021},
   issue_date = {October 2021},
   publisher = {VLDB Endowment},
   volume = {15},
   number = {2},
   issn = {2150-8097},
   url = {https://doi.org/10.14778/3489496.3489508},
   doi = {10.14778/3489496.3489508},
   journal = {Proc. VLDB Endow.},
   month = {oct},
   pages = {272–284},
   numpages = {13}
}
```
indico-sso-group-mapping 1.0.2
SSO group mapping plugin for Indico
Requires Python: <3.13,>=3.12.2

# Indico SSO Group Mapping [![CI Status][ci-badge]][ci-link] [![License][license-badge]][license-link] [![Available on PyPI][pypi-badge]][pypi-link]

An [Indico](https://getindico.io/) plugin to map SSO groups to local Indico groups.

## Installation
You can install the plugin directly from PyPI:
```
pip install indico-sso-group-mapping
```

## Functionality
This plugin adds users logging in via a given identity provider, configurably filtered by the domain of the identity, to a configurable local group. The goal is to grant privileges (such as room booking) to all users using a given identity provider and, optionally, identity domain. An example use case would be Shibboleth SSO via federated identities, only granting those users with a given identity domain local privileges.

Furthermore, this plugin features a celery cron job which can optionally clean out users from the local group after they have not used the configured identity provider and identity domain for a configured number of days. This covers changes in a user's affiliation.

## Settings
After installation, the plugin (named `SSO Group Mapping`) offers various settings in the Admin backend.

### Provider
The identity provider to which accounts need to be associated to be added to the group.

### Identities Domain
If non-empty, identities must match given domain.

### Local Users Group
The group to which anyone logging in with a matching SSO account is added.

### Enable daily Local Users Group cleanup
Enable periodic cleanup of Local Users Group for SSO accounts without login in configured days.

### Expire login after days
Days after which logins are considered too old and users are removed from group in cleanup.

(only shown if daily cleanup is enabled)

[ci-badge]: https://github.com/unibonn/indico-sso-group-mapping/actions/workflows/ci.yml/badge.svg
[ci-link]: https://github.com/unibonn/indico-sso-group-mapping/actions/workflows/ci.yml
[license-link]: https://github.com/indico/indico-plugins/blob/master/LICENSE
[license-badge]: https://img.shields.io/github/license/indico/indico.svg
[pypi-badge]: https://img.shields.io/pypi/v/indico-sso-group-mapping.svg
[pypi-link]: https://pypi.org/project/indico-sso-group-mapping/
itranslator 3.0
Text translation package based on Google Translate API
Requires Python: ~=3.7
Keywords: translate, translator, google, google-translate, free-translator, asyncio

# ITranslator
Text translation package based on Google Translate API

### Sync Example
```python
from itranslator import Translator

translator = Translator()

translated_text = translator.translate(query='hi there', to_lang='fa')
print(translated_text)
```

### Async Example
```python
from itranslator.asyncio import Translator
from asyncio import run

translator = Translator()


async def main():
    translated_text = await translator.translate("Hello", "fa")
    print(translated_text)

run(main())
```

### Install & Update
```bash
pip install itranslator -U
```
### License
ITranslator is released under the GPL-3.0 License. See the bundled [LICENSE](https://github.com/irvaniamirali/itranslator/blob/main/LICENSE) file for details.
bucketed-scene-flow-eval 2.0.25
Bucketed Scene Flow Evaluation
Requires Python: >=3.10

# Bucketed Scene Flow Evaluation

This repo provides the official implementation of _Bucket Normalized EPE_, as described in our paper [_I Can't Believe It's Not Scene Flow!_](https://vedder.io/trackflow.html)

This repo provides:
 - A speed and class aware evaluation protocol called _Bucket Normalized EPE_. See our [paper](https://vedder.io/trackflow.html) for more details.
 - A standardized interface for working with Scene Flow datasets.
 - Evaulation infrastructure for the [Argoverse 2 2024 Scene Flow Challenge](https://eval.ai/web/challenges/challenge-page/2210/overview).

Currently supported datasets:

 - Argoverse 2 (Human Labeled and [NSFP Pseudolabeled](https://github.com/kylevedder/BucketedSceneFlowEval/blob/master/docs/GETTING_STARTED.md#argoverse-2-nsfp-pseudolabels-new))
 - Waymo Open (LiDAR only)
 - NuScenes (LiDAR only, beta)


If you use this repository as part of a publication, please cite:

```
@inproceedings{khatri2024trackflow,
  author = {Khatri, Ishan and Vedder, Kyle and Peri, Neehar and Ramanan, Deva and Hays, James},
  title = {{I Can't Believe It's Not Scene Flow!}},
  journal = {European Conference on Computer Vision (ECCV)},
  year = {2024},
  pdf = {https://arxiv.org/abs/2403.04739},
  website={http://vedder.io/trackflow.html},
}
```

## Installation

```
pip install bucketed-scene-flow-eval
```

## Setup

Follow our [Getting Started](docs/GETTING_STARTED.md) for setup instructions.

## Demo

We provide a demo script which shows off the various features of the API.

### Argoverse 2:

To render the lidar and multiple camera views of an Argoverse 2 sequence in 3D, run:

```
python scripts/demo_3d.py --dataset Argoverse2CausalSceneFlow --root_dir /efs/argoverse2/val/ --with_rgb --sequence_length 4
```

![Argoverse 2 MultiCam](docs/imgs/av2_multicam.png)

To render RGB frames with lidar imposed on top, run:

```
python scripts/demo_rgb.py --dataset Argoverse2SceneFlow --mode project_lidar  --reduction_factor 16 --root_dir /efs/argoverse2/val --sequence_length 150 --save_dir /efs/av2_camera_render/
```

![Argoverse 2 LiDAR](docs/imgs/av2_lidar.gif)

To render the flow field of an Argoverse 2 sequence, run:

```
python scripts/demo_rgb.py --dataset Argoverse2SceneFlow --mode project_flow  --reduction_factor 16 --root_dir /efs/argoverse2/val --sequence_length 150 --save_dir /efs/av2_camera_render/ --flow_dir <path to method flow output>
```

![Argoverse 2 Flow](docs/imgs/av2_gt_flow.gif)

### Waymo Open:

```
python scripts/demo.py --dataset WaymoOpenSceneFlow --root_dir /efs/waymo_open_processed_flow/validation/
```

## Evaluating AV2 flow submissions

To evaluate an AV2 Scene Flow challenge entry named `./submission_val.zip` against validation dataset masks `/efs/argoverse2/val_official_masks.zip`, run

```
python scripts/av2_eval.py /efs/argoverse2/val /efs/argoverse2/val_official_masks.zip ./submission_val.zip
```

## Documentation

See `docs/` for more documentation .
fraee 0.1.0
A simple package
Requires Python: >=3.12

# Opis skryptu

Ten skrypt dostarcza funkcje do uzyskiwania informacji o sieci, generowania tekstu w kolorach tęczy oraz wyszukiwania największej liczby w podanym ciągu tekstowym. Poniżej znajduje się opis każdej z funkcji.

## Funkcje

### 1. `network_info()`

Funkcja `network_info` służy do uzyskania szczegółowych informacji o sieci. Zbiera ona dane dotyczące:
- **Nazwa hosta (Hostname)**: Zwraca nazwę hosta urządzenia.
- **Lokalny adres IP (Local IP)**: Zwraca lokalny adres IP przypisany do hosta.
- **Interfejsy sieciowe (Network Interfaces)**: Zwraca listę interfejsów sieciowych z przypisanymi adresami IP (IPv4 oraz IPv6).
- **Statystyki sieci (Network Stats)**: Zwraca statystyki dotyczące sieci, takie jak liczba bajtów wysłanych i odebranych na każdym interfejsie sieciowym.

#### Przykład użycia:
```python
info = network_info()
print(info)
```
``sekretne funkcje tez sa``
splint 0.1
Splint: A simple, easy-to-use Python linter designed for beginner developers.
Requires Python: >=3.6

# Splint

A fast, simple, and easy-to-use Python linter.

![Build Status](https://github.com/jerankda/splint/actions/workflows/python-publish.yml/badge.svg)
![License](https://img.shields.io/github/license/jerankda/splint)
![Version](https://img.shields.io/pypi/v/splint)


##Splint is a Python linter designed to help you catch common issues, enforce coding standards, and improve your Python code.

> ⚠️ **Note:** Splint is currently in early development

---

## Installation

```bash
pip install splint
```
## Features

### Working Features:
- **Syntax Checking**: Validates Python code syntax using `ast.parse`.
- **Indentation Checking**: Ensures correct indentation levels and alignment.
- **Line Length Checking**: Verifies that lines do not exceed a specified length.
- **Naming Conventions Checking**: Enforces snake_case for functions and classes, camelCase for variables, and CONSTANT_CASE for constants.
- **Unused Imports Checking**: Identifies and reports unused imports.
- **Docstrings Checking**: Ensures all functions, classes, and modules have docstrings.
- **Magic Numbers Checking**: Detects and flags "magic numbers" that are outside a specified range.
- **Code Complexity Checking**: Estimates complexity based on decision points within functions.
- **Deprecated Functions Checking**: Flags usage of deprecated functions.

### Not Yet Implemented:
- **Single Responsibility Principle Checking**: Analysis to ensure that each function or class adheres to the Single Responsibility Principle.
- **Formatting Checking**: Comprehensive checks for adherence to PEP8 formatting standards, including code style and formatting rules.
- **Cyclomatic Complexity Checking**: Analysis of cyclomatic complexity to measure the number of linearly independent paths through the code.
- **Magic Methods Checking**: Verification for the presence and proper implementation of common Python magic methods.
- **PEP8 Compliance**: Full compliance with PEP8 style guide for Python code.
- **Code Smells Detection**: Identification of common code smells that may indicate potential issues or areas for improvement.
- **Documentation Coverage Checking**: Verification to ensure that code is adequately documented.
- **Refactoring Opportunities Checking**: Detection of potential areas in the code that may benefit from refactoring.
- **Performance Checking**: Analysis to identify potential performance bottlenecks and optimizations.
- **Security Vulnerabilities Checking**: Identification of potential security vulnerabilities in the code.



## Usage

To use **Splint**, follow these steps:

1. **Clone the Repository**:
   ```
   git clone https://github.com/jerankda/splint
   cd simple_linter
   ```
2. **Install Dependencies:**
   ```
   pip install -r requirements.txt"
   ```
3. **Run the Linter:**
   ```
   python main.py <path-to-your-python-file>
   ```
   Replace <path-to-your-python-file> with the path to the Python file you want to lint.