semvec/pypi-packages huggingface dataset:
pytest-perf 0.15.0
Run performance tests against the mainline code.
Requires Python: >=3.8

.. image:: https://img.shields.io/pypi/v/pytest-perf.svg
   :target: https://pypi.org/project/pytest-perf

.. image:: https://img.shields.io/pypi/pyversions/pytest-perf.svg

.. image:: https://github.com/jaraco/pytest-perf/actions/workflows/main.yml/badge.svg
   :target: https://github.com/jaraco/pytest-perf/actions?query=workflow%3A%22tests%22
   :alt: tests

.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json
    :target: https://github.com/astral-sh/ruff
    :alt: Ruff

.. .. image:: https://readthedocs.org/projects/PROJECT_RTD/badge/?version=latest
..    :target: https://PROJECT_RTD.readthedocs.io/en/latest/?badge=latest

.. image:: https://img.shields.io/badge/skeleton-2024-informational
   :target: https://blog.jaraco.com/skeleton

Run performance tests against the mainline code.

Usage
=====

To use it, include pytest-perf in the test dependencies for your project, then create some Python module in your package. The plugin will include any module that contains the text "pytest_perf" and will run performance tests on each function containing "perf" in the name.

Tests don't execute the module directly, but instead parse out the code of the function in two parts, the warmup and the test, separated by a "# end warmup" comment, and then passes those to the ``timeit`` module.

See the ``exercises.py`` module for example usage.

Design
======

``pytest-perf`` works by creating two installs, the control and the experiment, and measuring the performance of some python code against each.

Under the hood, it uses ``pip-run`` to install from the upstream main branch (e.g. https://github.com/jaraco/pytest-perf) for the control and from ``.`` for the experiment. It then runs each of the experiments against each of the enviroments.
enochecker-cli 0.7.1
Enochecker CLI
Requires Python: >=3.8

# Enochecker CLI [![PyPI version](https://badge.fury.io/py/enochecker-cli.svg)](https://pypi.org/project/enochecker-cli) [![Build Status](https://github.com/enowars/enochecker_cli/actions/workflows/pythonapp.yml/badge.svg?branch=main)](https://github.com/enowars/enochecker_cli/actions/workflows/pythonapp.yml) ![Lines of code](https://tokei.rs/b1/github/enowars/enochecker_cli)


## Usage
```
usage: enochecker_cli [-h] [-A CHECKER_ADDRESS] [-i TASK_ID] [-a ADDRESS] [-T TEAM_ID] [-t TEAM_NAME] [-r CURRENT_ROUND_ID] [-R RELATED_ROUND_ID] [-f FLAG] [-v VARIANT_ID] [-x TIMEOUT] [-l ROUND_LENGTH] [-I TASK_CHAIN_ID]
                      [--flag_regex FLAG_REGEX] [--attack_info ATTACK_INFO]
                      {putflag,getflag,putnoise,getnoise,havoc,exploit}

Your friendly checker script

positional arguments:
  {putflag,getflag,putnoise,getnoise,havoc,exploit}
                        One of ['putflag', 'getflag', 'putnoise', 'getnoise', 'havoc', 'exploit']

options:
  -h, --help            show this help message and exit
  -A CHECKER_ADDRESS, --checker_address CHECKER_ADDRESS
                        The URL of the checker
  -i TASK_ID, --task_id TASK_ID
                        An id for this task. Must be unique in a CTF.
  -a ADDRESS, --address ADDRESS
                        The ip or address of the remote team to check
  -T TEAM_ID, --team_id TEAM_ID
                        The Team_id belonging to the specified Team
  -t TEAM_NAME, --team_name TEAM_NAME
                        The name of the target team to check
  -r CURRENT_ROUND_ID, --current_round_id CURRENT_ROUND_ID
                        The round we are in right now
  -R RELATED_ROUND_ID, --related_round_id RELATED_ROUND_ID
                        The round in which the flag or noise was stored when method is getflag/getnoise. Equal to current_round_id otherwise.
  -f FLAG, --flag FLAG  The flag for putflag/getflag or the flag to find in exploit mode
  -v VARIANT_ID, --variant_id VARIANT_ID
                        The variantId for the method being called
  -x TIMEOUT, --timeout TIMEOUT
                        The maximum amount of time the script has to execute in milliseconds (default 30 000)
  -l ROUND_LENGTH, --round_length ROUND_LENGTH
                        The round length in milliseconds (default 300 000)
  -I TASK_CHAIN_ID, --task_chain_id TASK_CHAIN_ID
                        A unique Id which must be identical for all related putflag/getflag calls and putnoise/getnoise calls
  --flag_regex FLAG_REGEX
                        A regular expression matched by the flag, used only when running the exploit method
  --attack_info ATTACK_INFO
                        The attack info returned by the corresponding putflag, used only when running the exploit method
```

## Installation
`pip3 install enochecker_cli`
eurelis-langchain-solr-vectorstore 0.0.3
Library that provide a Solr based vector store for Langchain
Requires Python: >=3.11

# Eurelis-Langchain-SolR-VectorStore

![Python : 11](https://img.shields.io/badge/Python-=3.11-green)
![Code style : black](https://img.shields.io/badge/Code_style-black-black)
![Linting : pylint](https://img.shields.io/badge/Linting-pylint-yellowgreen)

This library allows to use a Solr based vector store with the python version of [LangChain](https://www.langchain.com)

## Usage

This library assume you already have a running Solr instance with a configured dense vector field

```xml
<fieldType name="knn_vector" class="solr.DenseVectorField" vectorDimension="768" similarityFunction="euclidean"/>
<field name="vector" type="knn_vector" indexed="true" stored="true"/>
```

Be sure to set a vectorDimension value corresponding to what yor embeddings model provide.

```python
from langchain.embeddings import HuggingFaceEmbeddings
from eurelis_langchain_solr_vectorstore import Solr

embeddings = HuggingFaceEmbeddings()  # you are free to use any embeddings method allowed by langchain

vector_store = Solr(embeddings)  # with default core configuration
```

You can also specify data about the solr instance and core to use:

```python
vector_store = Solr(embeddings, core_kwargs={
    'page_content_field': 'text_t',  # field containing the text content
    'vector_field': 'vector',        # field containing the embeddings of the text content
    'core_name': 'langchain',        # core name
    'url_base': 'http://localhost:8983/solr', # base url to access solr
    'query_handler': 'select', # handler to use to query solr
    'update_handler': 'update', # update handler for solr
    'metadata_fields': [] # additional solr fields to consider as metadata, ie ['id']
})  # with custom default core configuration
```

In the code above you have both the allowed core arguments and the default value.

### Metadata

The Solr based vector store also supports storing and filtering on metadata.

Metadata are mapped into Solr using the following convention: metadata_*{key}*_*{type}* with 
key being the original metadata key, and type is automatically inferred as:

- *i* for integer fields
- *d* for float fields
- *s* for string fields
- *b* for boolean fields

The *vector_search* method take an optional *where* param expecting a dict:

- dict item key: base name of a metadata field
- dict item value: value expected in the metadata field

Example using the vector store as a retriever:

```python
retriever = vector_store.as_retriever()
```

Example adding filter instructions to the retriever
```python
retriever = vector_store.as_retriever(search_kwargs={'filter': {'language': 'en', 'year': 2000}})
```

## Docker

A docker compose file is present in the etc/docker folder, use it with

```bash
docker compose up -d
```

To launch a solr instance with a core named *langchain* and a 'vector' field with 768 dimensions.
p3270 0.1.6
Python library to communicate with IBM hosts
Keywords: IBM CICS 3270 TN3270 test automation Mainframe z/OS


    A Python library that provides an interface to communicate with IBM hosts: send commands and text, receive output (screens). The library provides the means to do what a human can do using a 3270 emulator.

    The library is highly customizable and is built with simplicity in mind.
    It is written in Python 3, runs on Linux and Unix-like Operating Systems, and relies on the `s3270` utility. So it is required to have the `s3270` installed on your system and available on your PATH.

    The library allows you to open a telnet connection to an IBM host, and execute a set of instructions as you specified them in your python program.
spistats 0.1.0
Analyse the performances of sequential private identifiers: a LorWan privacy orentied communication protocol.  Efficient numerical method to compute the mass function and the CDF of streaks of repeating events. Expectation of packet loss computed using Markov chains for improved performance.  This work is based on an extention of https://inria.hal.science/hal-04525080.  Please cite this paper if you use this package in your research project.
Requires Python: >=3.7

LoRaWAN, a widely deployed LPWAN protocol, raises privacy concerns due to metadata exposure, particularly concerning the exploitation of stable device identifiers. For the first time in literature, we propose two privacy-preserving pseudonym schemes tailored for LoRaWAN: resolvable pseudonyms and sequential pseudonyms. We extensively evaluate their performance and applicability through theoretical analysis and simulations based on a large-scale real-world dataset of 71 million messages. We conclude that sequential pseudonyms are the best solution.

This repository analyses the performances of sequential private identifiers: a LoRaWAN privacy orentied communication protocol.

We use efficient numerical methods to compute the mass function and the CDF of streaks of repeating events. The expectation of packet loss is computed using Markov chains for improved performances.

# Research work
This work is based on an extention of the follwoing research paper: https://inria.hal.science/hal-04525080 Please cite this paper if you use this package in your research project.

# Installation 
```bash
pip install spistats
```

# Documentation
The full API documentation is available here https://jaalmoes.com/doc/spistats/.

# Usage
## Generating figures of the paper
```bash
python -m spistats.markov
```
## Collision
```python
import spistats as spi
col = spi.Collision(nbr_dev, nbr_adr, adr_per_dev)
```

## Desynchronization
```python
import spistats.desynchronization as dsync
packet_count = dsync.NumberOfPacketBeforeDsync(0.2,5)
packet_count = dsync.NumberOfPacketBeforeDsync_multi([0.2,0.3],5)
```

## Plotting
```python
import spistats.plot as plt
import spistats.desynchronization as dsync
dsync_count = dsync.NumberOfDsync(0.2,2,10)
plt.cdf(dsync_count)
```