semvec/pypi-packages huggingface dataset:
rf-azure-sync 1.0.1
Synchronization functionalities for Azure-related tasks.
Keywords: Azure,synchronization,robotframework

# Robot Framework Azure Sync 

## Overview

The **Robot Framework Azure Sync** package provides synchronization capabilities for Azure-related tasks. It includes scripts to retrieve data from Azure Test Cases **(`rf_azure_sync_get.py`)**, to update Azure Test Cases **(`rf_azure_sync_patch.py`)**, and to run Robot Framework tests with specific tags.

## Installation

To install `rf_azure_sync`, you can use `pip`. Open a terminal and run:

```bash
pip install rf-azure-sync
```

## Using the project source code

Alternatively, you can download the project source code from the repository and use it directly. You will need to have Python installed on your system.

1. Clone the repository:

```bash
git clone https://github.com/fabiorisantosquispe/rf_azure_sync.git
```

2. Navigate to the project directory:

```bash
cd rf_azure_sync
```
3. Use the provided scripts

- sync_utils.py: Contains utility functions for synchronization.
- rf_azure_sync_get.py: Script to get data from Azure Test Cases.
- rf_azure_sync_patch.py: Script to patch data to Azure Test Cases.
- rf_azure_sync.py: Main script for synchronization and running Robot Framework tests.


# Usage
## Using the installed package
If you installed the package via pip, you can use the following commands:

```bash
#Run synchronize_get and synchronize_patch
rf_azure_sync

#Just run sync_get
rf_azure_sync get

#Run sync_patch only
rf_azure_sync patch
```

## Using the project source code
If you are using the project source code directly, you can execute the scripts using Python:

```bash
# Run synchronize_get and synchronize_patch
python rf_azure_sync.py

# Just run sync_get
python rf_azure_sync.py get

# Run sync_patch only
python rf_azure_sync.py patch
```

# Configuration
The package requires a configuration file **'sync_config.json'** with Azure-related settings. If the file is not found, it will be created interactively.

Example **'sync_config.json'**:
```JSON
{
     "path": "tests",
     "credentials": {
       "personal_access_token": "your_azure_personal_access_token",
       "organization_name": "your_organization_name",
       "project_name": "your_project_name"
     },
     "tag_config": {
       "test_case": "TC",
       "user_story": "US",
       "bug": "Bug",
       "title": "Title",
       "TestedBy-Reverse": "",
       "IterationPath": "",
       "AutomationStatus": "",
       "ignore_sync": "",
       "System.Tags": "",
       "Priority": ""
     },
     "constants": {
       "System.AreaPath": "",
       "System.TeamProject": "",
       "settings_section": "",
       "test_cases_section": ""
     }
}
```
cs4900-Geometry-Package-Team-1 0.0.1
Geometry Package
Requires Python: >=3.8

# Team 1 4900 first project

Computational Geometry package for Python. 

# This package grants functionality on a 2-d euclidean plane.
# Functionalities include:

- Line segment intersection: Find the intersections between a given set of line segments.
- Closest pair of points: Given a set of points, find the two with the smallest distance from each other.
- Convex hull: Given a set of points, find the smallest convex polyhedron/polygon containing all the points, represented as the set of points on the polygon edge.
- Largest empty circle: Given a set of points, find a largest circle with its center inside of their convex hull and enclosing none of them.
- graphing all of the above listed functionalities

## How to Call new_math.py functions: 

generate_random_list_of_points(): Returns a tuple of x,y points

Line segment intersection:        show_all_line_intersections(list_of_your_lines) 

Closest pair of points:           find_closest_pair_of_points(list_of_points)

Convex hull:                      show_convex_hull(list_of_your_points)

Largest empty circle:       l     largest_inside_circle(list_of_your_points) 


## How to Call graphing.py functions - use tuples

add_points(list_of_points)

show_closest_pair(list_of_points)               - shows all points, and the closest pair of points.

show_all_lines_and_intersections(list_of_lines) - Shows all intersections between lines

show_largest_inside_circle(list_of_points)      - Shows largest empty circle

show_convex_hull(list_of_points)                - Shows convex hull

# TEAM REFERENCES:

- HOW TO CREATE PACKAGES - https://packaging.python.org/en/latest/tutorials/packaging-projects/
- Alex's example package - https://test.pypi.org/project/test-cs-4900-package-creation/0.0.1/
- Convex Polygon incircle - https://observablehq.com/@mbostock/convex-polygon-incircle
- Closest pair of points example algorithm: https://www.geeksforgeeks.org/closest-pair-of-points-using-divide-and-conquer-algorithm/
- Two line intersection example 1: https://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect
- Two line intersection example 2: https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection
- Convex Hull algorithms, I think we should use Grahm Scan: https://en.wikipedia.org/wiki/Convex_hull_algorithms
- For largest circle find the max point, find the min point and the use the circle equation to draw the circle
- For line intersection: https://stackoverflow.com/questions/20677795/how-do-i-compute-the-intersection-point-of-two-lines
LiveCandles 0.0.2
API for getting live OHLC candle-stick data of Indian Stocks for free
Requires Python: >=3.9.6
Keywords: OHLC feed,stock,candle stick,stock market

API for live OHLC feed

[![PyPI version](https://badge.fury.io/py/your-project-name.svg)](https://badge.fury.io/py/your-project-name)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)

## Installation

You can install project using pip:

```python
pip install LiveCandles
```

## Description

Use this API for getting live OHLC candle-stick for free, it will relay the data of time intervals from 5 to 59 minutes starting from the next mutiple for 5 minute. 

It has two modes for getting data as shown below:

1. It simply web scraps the google finance webpage to get live current price and converts in to OHLC candle. Code for it is

```python
data  = LiveCandles.ohlcStream('5minutes',indexCode = "NIFTY_50")

while True:
    price = data.stream()
    #use price as per your need
    print(price)
```

2. It will use multiprocessing to set open, high, low, close values simultaneously  

```python
from LiveCandles import ohlcStream

if __name__ == '__main__':    
    data = ohlcStream("5minutes", indexCode = "NIFTY_50")

    while True:
        price = (data.streamMP())
        #use price as per your need
        print(price)
```

## Arguments: 
1. First argument is interval should be specified as '5minutes' number can be anything from 5 to 59

2. indexCode(optional) to be specified to get index candle as per google finance code

3. stockCode(optional) to be specified to get stock candle as per google finance code

## DISCLAIMER

Data generated is not very accurate, due to netwrok latency, call restriction. Avoid using for taking order placing decsions on it's basis. One can override getCurrentPrice() method for more reliable price fetching.
rand-wordpair 0.0.1
Python module to generate a random pair of English words
Requires Python: >=3.10

# rand\_wordpair
Python module to generate a random pair of English words

# Usage

To get a random pair of words:

    from rand_wordpair import gen_pair
    print(gen_pair()) # different every time, e.g. sudsy-pickup

To get a username-based code (e.g. for SD212 homework):

    from rand_wordpair import show_user_code
    show_user_code() # prints code wordpair to the screen

# Dependencies

Uses [nltk](https://www.nltk.org/) for and the
[WordNet database](https://wordnet.princeton.edu/).

# Build instructions

Follow [this tutorial on packaging](https://packaging.python.org/en/latest/tutorials/packaging-projects/)
and [this quickstart for setuptools](https://setuptools.pypa.io/en/latest/userguide/quickstart.html).

Pip/conda/mamba packages needed:

    build twine

To test:

    python3 test.py

To build:

    python3 -m build

To publish on pypi (requires account setup and
[api token](https://test.pypi.org/manage/account/token/)):

    python3 -m twine upload --repository testpypi dist/*
authix 0.0.7
Authix - Authentication as a service
Requires Python: >=3.10

# Authix: Scalable Authentication Service

Welcome to **Authix**, an authentication service designed based on a [talk by
Brian Pontarelli](https://www.youtube.com/watch?v=SLc3cTlypwM).

Authix provides a comprehensive solution for user authentication, built on the
principles of JWT (pronounced 'jot') and refresh tokens.

## Key Features

1. **User Registration**: Users can sign up using their email and password.
   Users are stored in MongoDB.

2. **User Login**: Upon successful login, users receive:

   - A JWT access token in the Authorization header for immediate access.
   - A longer-lived refresh token as an HTTP cookie for extended sessions.

3. **Access Token Management**: Generate new JWT access tokens using the
   provided refresh token, ensuring seamless user experiences.

4. **Public Key**: Services can verify JWTs independently via public key,
   thereby reducing inter-service network calls.

5. **Secure Logout**: Users are logged out by deleting their refresh token from
   storage, which thereby removes the possibility to create new access tokens.
   Furthermore, it informs all connected services via Kafka to reject JWTs from
   the logged-out user, that have been created prior to logging out.

6. **Token Lifespan**:
   - JWT access tokens are valid for 5 minutes.
   - Refresh tokens, stored in REDIS, last for 4 weeks.

## Diagrams

### User Perspective

```mermaid
graph TB
  A["User"] -- "Register" --> B["/register"]
  A -- "Login" --> C["/login"]
  C -- "JWT & Refresh Token" --> A
  A -- "Use Refresh Token" --> D["/access_token"]
  D -- "New JWT" --> A
  A -- "Logout" --> E["/logout"]
```

### Service Perspective

```mermaid
graph TB
  S["Service"] -- "Retrieve Public Key" --> PK["/public_key"]
  S -- "Verify JWT" --> V["Verify JWT using Public Key"]
  S -- "Handle Logout Broadcast" --> L["Reject soon-to-expire JWTs"]
```

## Performance

On a single computer, running Authix via uvicorn with 16 workers, expect:

Create 1K users

```
1000 /register

2.97 seconds
```

Create 1K users, and login each user.

```
1000 /register
1000 /login

6.28 seconds
```

Create 10 users, for each user login, and call `/access_token` 1K times.

```
10 /register
10 /login
10000 /access_token

3.43 seconds
```
liveCandles 0.0.1
API for getting live OHLC candle-stick data of Indian Stocks for free
Requires Python: >=3.9.6
Keywords: OHLC feed,stock,candle stick,stock market

API for live OHLC feed

[![PyPI version](https://badge.fury.io/py/your-project-name.svg)](https://badge.fury.io/py/your-project-name)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)

## Installation

You can install project using pip:
Strictly use pip only

```python
pip install liveOhlc-Feed==0.0.1
```

## Description

Use this API for getting live OHLC candle-stick for free, it will relay the data of time intervals from 5 to 59 minutes starting from the next mutiple for 5 minute. 

It has two modes for getting data as shown below:

1. It simply web scraps the google finance webpage to get live current price and converts in to OHLC candle. Code for it is

```python
import liveCandles
data  = liveCandles.ohlcStream('5minutes',"NIFTY_50")

while True:
    price = data.stream()
    #use price as per your need
    print(price)
```

2. It will use multiprocessing to set open, high, low, close values simultaneously  

```python
import liveCandles
from liveCandles import ohlcStream

if __name__ == '__main__':    
    data = ohlcStream("5minutes", indexCode="NIFTY_50")

    while True:
        price = (data.streamMP())
        #use price as per your need
        print(price)
```
liveOhlc-Feed 0.0.1
API for getting live OHLC candle-stick data of Indian Stocks for free
Requires Python: >=3.9.6
Keywords: OHLC feed,stock,candle stick,stock market

API for live OHLC feed

[![PyPI version](https://badge.fury.io/py/your-project-name.svg)](https://badge.fury.io/py/your-project-name)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)

## Installation

You can install project using pip:
Strictly use pip only

```python
pip install liveOhlc_Feed==0.0.1
```

## Description

Use this API for getting live OHLC candle-stick for free, it will relay the data of time intervals from 5 to 59 minutes starting from the next mutiple for 5 minute. 

It has two modes for getting data as shown below:

1. It simply web scraps the google finance webpage to get live current price and converts in to OHLC candle. Code for it is

```python
import liveOHLC_Feed
data  = liveOHLC_Feed.ohlcStream('5minutes',"NIFTY_50")

while True:
    price = data.stream()
    #use price as per your need
    print(price)
```

2. It will use multiprocessing to set open, high, low, close values simultaneously  

```python
import liveOHLC_Feed
from liveOHLC_Feed import ohlcStream

if __name__ == '__main__':    
    data = ohlcStream("5minutes", indexCode="NIFTY_50")

    while True:
        price = (data.streamMP())
        #use price as per your need
        print(price)
```
onsapi 0.2.2
A package for interacting with the UK Office for National Statistics' Beta API.
Requires Python: >=3.8

### Installation

You can install this package using pip.

```
pip install onsapi
```

### Example usage

You can get a list of all datasets available on the ONS API.

```
from onsapi import OnsApiClient

client = OnsApiClient()
datasets = client.list_datasets()
```

Information about each dataset can be pretty printed to the command line.

```
selection = datasets[0]
print(selection)
```

You can load a dataset as a dataframe.

```
selection.download_csv()
df = selection.load_as_df()
```
liveOhlcFeed 0.0.1
API for getting live OHLC candle-stick data of Indian Stocks for free
Requires Python: >=3.9.6
Keywords: OHLC feed,stock,candle stick,stock market

API for live OHLC feed

[![PyPI version](https://badge.fury.io/py/your-project-name.svg)](https://badge.fury.io/py/your-project-name)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)

## Installation

You can install project using pip:

```bash
pip install liveOHLCFeed
```

## Description

Use this API for getting live OHLC candle-stick for free, it will relay the data of time intervals from 5 to 59 minutes starting from the next mutiple for 5 minute. 

It has two modes for getting data as shown below:

1. It simply web scraps the google finance webpage to get live current price and converts in to OHLC candle. Code for it is

```python
import liveOHLCFeed
data  = liveOHLCFeed.ohlcStream('5minutes',"NIFTY_50")

while True:
    price = data.stream()
    #use price as per your need
    print(price)
```

2. It will use multiprocessing to set open, high, low, close values simultaneously  

```python
import liveOHLCFeed
from liveOHLCFeed import ohlcStream

if __name__ == '__main__':    
    data = ohlcStream("5minutes", indexCode="NIFTY_50")

    while True:
        price = (data.streamMP())
        #use price as per your need
        print(price)
```
romanlibrary 1.3.1
A Python library for drawing Roman numerals using Turtle graphics
Keywords: roman numeral turtle graphics drawing

This my first major project in Python that I am publishing to GitHub.
The main idea is that it will take any integer and draw it in roman numerals.
It can also convert roman numerals into integers, although the integers will be printed.
One other user side function allows the user to specify what numerals, what order and which size.
The URL for the GitHub is https://github.com/nicestuff77/roman-numeral