semvec/pypi-packages huggingface dataset:
pmotif-lib 1.0.2
Perform motif detection, either with traditional frequency, or with positional metrics for each graphlet occurrence.
Requires Python: >=3.7

# pmotif_lib

Perform motif detection, either with traditional frequency, or with positional metrics for each graphlet occurrence.

This library implements each step of a (p)motif detection pipeline such as 
- graphlet detection in networks
- randomization of networks
- frequency comparison of graphlet occurrences
- positional metric comparison of graphlet occurrences.

## Setup
Install this package:
```
pip install pmotif-lib
```

This library relies on the `gtrieScanner` tool. Please [download it](https://www.dcc.fc.up.pt/gtries/), compile it, and add the executable to your path.

Finally, this library loads environment variables. Create an `.env` file::
```bash
export DATASET_DIRECTORY=/path/where/edgelists/are/located
export EXPERIMENT_OUT=/path/where/raw/graphlets/and/pmetric/should/go
export GTRIESCANNER_EXECUTABLE=/path/to/the/gtriescanner/executable
export WORKERS=1  # Optional, controls the max. degree of parallelization
```
In order to make these variablea available to the library, use `source .env` before command line usage!
You can also use the `python-dotenv` package to load the `.env` file from python code:
```python
from dotenv import load_dotenv

load_dotenv(".env")
```

## Usage
`showcase/` contains a number of examples:
- graphlet detection
- p-graphlet detection
- motif detection
- p-motif detection

After installing `pmotif_lib`, navigate into `showcase/`, run `source .showcase_env`, and then run `python3 graphlet_detection` (or one of the other examples).
This expects the `gtrieScanner` executable to be in your system's path under `gtrieScanner`!

## Glossary
- Induced Subgraph: A graph created by cutting out a set of nodes from a graph `G`, retaining all edges between these nodes
- Isomorphic graphs: Graphs, that are structurally the same when ignoring node labels
- Isomorphic Classes of Size k: A set of graphs with k nodes, so that every other graph with k nodes is isomorphic to one graph in the set
- k-Graphlet: An isomorphic class of size k, so that at least one induced subgraph in a graph `G` is isomorphic to that class
- Graphlet Occurrences: All induced sub-graphs in a graph `G` that belong to a specific k-Graphlet
- Graphlet Frequency: The number of graphlet occurrences of a specific k-graphlet in a graph `G`
- Graph Motif: A k-Graphlet, which has a graphlet frequency which is significantly higher than expected, usually tested against randomized graphs generated based on `G`
- p-Motif: A k-Graphlet, which has graphlet occurrences with a significant expression of a positional metric, when compared against randomized graphs generated based on `G`
django-components-storybook 0.0.1
A package for creating Storybook stories for Django Components
Requires Python: >=3.7

# django-components-storybook

Create [Storybook](https://storybook.js.org/) stories for [Django Components](https://github.com/EmilStenstrom/django-components).

Inspired by [View Component Storybook](https://jonspalmer.github.io/view_component-storybook/) of Ruby on Rails [View Component](https://viewcomponent.org/). Uses [Storybook Server Framework](https://github.com/storybookjs/storybook/tree/next/code/frameworks/server-webpack5).

> **Warning:** This is a very early stage draft of the initial idea.

**Roadmap**

- Handle slots
- Generate ``.storybook/preview-head.html`` 
- Generate stories automatically
flaxspeaker 0.0.2
A simple speaker recognition library in JAX and Flax.

# FlaxSpeaker

 [![Python application](https://github.com/wq2012/FlaxSpeaker/actions/workflows/python-app.yml/badge.svg)](https://github.com/wq2012/FlaxSpeaker/actions/workflows/python-app.yml) [![PyPI Version](https://img.shields.io/pypi/v/flaxspeaker.svg)](https://pypi.python.org/pypi/flaxspeaker) [![Python Versions](https://img.shields.io/pypi/pyversions/flaxspeaker.svg)](https://pypi.org/project/flaxspeaker) [![Downloads](https://pepy.tech/badge/flaxspeaker)](https://pepy.tech/project/flaxspeaker)


## Overview

 A simple speaker recognition library in [JAX](https://jax.readthedocs.io) and [Flax](https://flax.readthedocs.io).

 For the PyTorch version, see: [SpeakerRecognitionFromScratch](https://github.com/wq2012/SpeakerRecognitionFromScratch)

## Installation

```
pip install flaxspeaker
```

## Tutorial

### Experiment config

All your experiment configurations are represented in a single YAML file.

See [myconfig.yml](myconfig.yml) as an example.

### Hook up with data

In the configuration file, you need to correctly hook it up with your
downloaded dataset.

For example, if you have downloaded LibriSpeech on your own machine, you need
to set these two fields correctly:

```
data:
  train_librispeech_dir: "YOUR LIBRISPEECH TRAINING SET PATH"
  test_librispeech_dir: "YOUR LIBRISPEECH TESTING SET PATH"
```

If you are using a different dataset than LibriSpeech, you need to represent
your dataset as CSV files. Then set these two fields correctly:

```
data:
  train_csv: "YOUR TRAINING SET CSV"
  test_csv: "YOUR TESTING SET CSV"
```

### Generate dataset CSV

To represent your downloaded datasets by CSV files, you can use the
`generate_csv` mode for the `flaxspeaker` command.

For example, you can use a command like below to
generate a CSV file `CN-Celeb.csv` to represent your downloaded CN-Celeb
dataset located at `"${HOME}/Downloads/CN-Celeb_flac/data"`:

```
python -m flaxspeaker \
--mode generate_csv \
--path_to_dataset "${HOME}/Downloads/CN-Celeb_flac/data" \
--audio_format ".flac" \
--speaker_label_index -2 \
--output_csv "CN-Celeb.csv"
```

You can use `--help` to understand the meaning of each flag:

```
python -m flaxspeaker --help
```

### Training

Once you have the config file ready (e.g. `your_config.yml`), you can launch
your training with this command:

```
python -m flaxspeaker --mode train --config your_config.yml
```

### Evaluation

After you finished training, you can evaluate the Equal Error Rate (EER) of
the model you just trained with:

```
python -m flaxspeaker --mode eval --config your_config.yml
```
PyFaudit 0.1.0
A python package to scan Python files, check encoding issues and provide an audit summary


# PyFaudit

PyFaudit is a Python utility to scan Python files in a directory (and its subdirectories), check for encoding issues, and provide a summary of the files scanned.

## Installation

You can install PyFaudit with pip:
`pip install PyFaudit`


## Usage

You can use PyFaudit from the command line or import it in your Python script.

### Command line

Run PyFaudit from the command line like this:
`PyFaudit /path/to/your/directory`

For verbose output, use the `-v` or `--verbose` option:
`PyFaudit /path/to/your/directory --verbose`


### Python script

Here is how to use PyFaudit in a Python script or Jupyter notebook:

```python
from PyFaudit import scan_files

total_files, total_size, problem_files = scan_files('/path/to/your/directory')
```
The scan_files function returns a tuple containing the total number of files scanned,
the total size of scanned files in bytes, and a list of paths to the files that
caused a UnicodeDecodeError.
pyne-script-utilities 1.0.5
A set of utility sub-modules that allow for code structure similar to pinescript in python
Requires Python: >=3.10

# Pyne Script

Pyne Script aims to offer a set of utility sub-modules that allow for code structure similar to Trading View Pine Script in Python.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install pyne_script.

```bash
pip install pyne-script-utilities
```

## Available sub-modules

- [series.py](https://github.com/80sVectorz/pyne_script/blob/main/docs/README_series.md)

## Contributing

Pull requests are welcome. For major changes, please contact me first
to discuss what you would like to change.

## License

[GPL-3.0](https://choosealicense.com/licenses/gpl-3.0/)
MetaFEDOT 0.0.5
Framework for meta-optimisation in AutoML tasks

# MetaFEDOT

MetaFEDOT is an open platform for sharing meta-learning experiences in **AutoML** and more
general **Graph Optimization**.
The project has 3 major long-term goals:

1. Provide codebase and utilities for experiments in meta-learning (work in progress)
2. Accumulate metaknowledge for popular application fields, such as tabular classification, tabular regression,
   time series forecasting, etc., based on public datasets and benchmarks (work in progress)
3. Provide user API allowing outer target-independent usage of accumulated meta-knowledge (planned)

## Codebase and utilities for experiments in meta-learning

This framework consists of several key components that automate and enhance the process of meta-learning. It provides
functionalities for dataset and model management, meta-features extraction, dataset similarity assessment. The
components work together to facilitate the initial approximation fitting process.

Each of the components may include different implementations while staying compatible. This is achieved by specification
and maintaining their external interfaces.

### Datasets loader & Dataset

Automate dataset management, including retrieval, caching, and loading into memory. Optimize experiments by minimizing
calls to the dataset source and conserve memory usage.

### Models Loader & Model

Import and consolidate model evaluation data for datasets. Support experiment selection based on predefined criteria,
currently compatible with FEDOT AutoML framework results.

### Meta-features Extractor

Automates the extraction of meta-features from datasets, improving efficiency by caching values. Can load dataset data
if it is necessary for meta-features extraction. For example, one of implementations utilize the PyMFE library for
meta-feature extraction.

### Datasets Similarity Assessor

Assesses dataset similarity based on meta-features. For a given dataset, provides list of similar datasets and optionally calculates
similarity measures. For example, one of implementations uses the "NearestNeighbors" model from scikit-learn.

### Models Advisor

Combines results from Models Loader and Datasets Similarity Assessor. Provides recommendations for models based on
loaded data and similar datasets. Possible implementations allow for heuristic-based suggestions.
streamlit-picture-carousel 0.1.5
Displays 3d carousel of pictures
Requires Python: >=3.7

# streamlit-picture-carousel

Displays 3d carousel of pictures

## Installation instructions 

```sh
pip install streamlit-picture-carousel
```

## Usage instructions

```python
import streamlit as st

from st_picture_carousel import st_picture_carousel

value = st_picture_carousel()

st.write(value)
ePos-Print-XML 0.3
Library to communicate with Epson thermal printers via ePOS-Print XML protocol
Requires Python: >=3.10
Keywords: epos,printing,receipt,thermoprinter,voucher printer

# py-epos-print-xml
Python library to communicate with Epson thermal printers via ePos-Print XML.
This makes it easy and intuitive to create print orders for ePos-Print XML compatible printers, like the Epson TM-T20, TM-m30 and TM-m50 series.
Depending on the printer model, some elements are not supported. Check your manual or the [Epson reference](https://reference.epson-biz.com/modules/ref_epos_print_xml_en/index.php?vid=ref_epos_print_xml_en_devicespecifications_supportedelementslist) to see which elements are supported.

## Instaling
```
pip install ePos-Print-XML
```

## Example

```python
from epos.printer import Printer
from epos.document import EposDocument
from epos.elements import Text, Feed, Barcode
from epos.constants import Align

# Create a new printer object with 10.0.0.12 as ip
printer = Printer('10.0.0.12')
# Check if we can connect to the printer with no errors, otherwise exit
if not printer.printer_ready():
    exit()

# Create a new EposDocument object
# This will contain all the individual elements
doc = EposDocument()

# Add an element directly to the body of the document
doc.add_body(Text('This is example text!\n'))
doc.add_body(Feed())  # Another way to add a newline

# It's also possible to first create the text object and then change the properties
t = Text('Some special text :O\n')
t.bold = True
t.align = Align.CENTER
doc.add_body(t)

# Add 2 empty lines
doc.add_body(Feed(2))

# Add a barcode
doc.add_body(Barcode(BarcodeType.CODE39, 'text in barcode'))

# Send the whole document to the printer
# This will automatially send a Cut at the end of the document body
r = printer.print(doc)

# The print method returns a response element
# Here we can check if the printing was succesfull
if r.success:
    print('The printing was successfull!')
else:
    print(f'Printing failed. Error: {r.code}')
```


## Documentation
Tech reference of all the xml elements by Epson: https://reference.epson-biz.com/modules/ref_epos_print_xml_en/index.php?content_id=1