semvec/pypi-packages huggingface dataset:
py-ssh-echo 0.0.1
A ssh echo server which provides an interactive shell
Requires Python: >=3.9

# py-ssh-echo

A simple **AsyncSSH-based echo SSH server** designed for testing purposes. This server provides an interactive shell and will echo any input sent over SSH, and logs basic session information (e.g., username, IP, bytes received, session duration) to stdout.

---

## Features

- **Echoes input**: Whatever you send to the server is echoed back, line by linepy.
- **Tracks session metadata**: Collects details like username, IP address, bytes received, and session duration.
- **Easy to use**: Can be run as a standalone server or imported as a module in other Python projects.
- **Customizable**: Choose the port for the server, and track session details through a callback function.

---

## Installation

You can install this package from PyPI:

```bash
pip install ssh-echo-server
```

Alternatively, you can install it from the source:

```bash
git clone https://github.com/yourusername/ssh-echo-server.git
cd ssh-echo-server
pip install .
```

---

## Usage

### As a standalone server

Run the server from the command line:

```bash
python -m ssh_echo_server.server
```

By default, the server will run on **localhost:2222**. You can specify a custom port by passing it as an argument:

```bash
python -m ssh_echo_server.server 2022
```

### As an imported module

You can also import and run the server from your Python scripts:

```python
from ssh_echo_server import start_echo_server

async def main():
    # Optionally, define a callback to track session data
    def track_session(info):
        print(f"Session ended: {info}")

    # Start the echo server on a custom port
    server = await start_echo_server(port=2022, session_tracker=track_session)

    try:
        await asyncio.sleep(60)  # Keep the server running for 60 seconds
    finally:
        # Gracefully shut down the server
        server.close()
        await server.wait_closed()

import asyncio
asyncio.run(main())
```

---

## Running Tests

This package includes unit tests that ensure the server functions correctly.

### Install the test dependencies:

```bash
pip install -r requirements.txt
```

### Run the tests with pytest:

```bash
pytest
```
### Run the tests with logs:
'''bash
pytest -s
'''

---

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

---

## Contributing

1. Create a new branch.
2. Make your changes.
3. Create a pull request.

---

## Author

Chris Morgan
rametest 0.0.4
rame test

# rametest v0.0.4

**Project**: rametest
<br>**Version**: 0.0.4
<br>**OS**: OS Independent
<br>**Author**: ika
<br>**Mail**: ika@gmail.com

**rametest** is a Python command-line interface application. rame test

## Installation

To use **rametest**, follow these steps:

- Open CMD and run the following command to install `pip install rametest` then restart your CMD
- To check if **rametest** is installed correctly, run the following command `rametest`

## Commands

These are the available commands you can use:

- `rametest` - To list available commands
- `rametest demo (param)` - Test demo method with param
cconfetti 0.1.0
Confetti configuration language, official C bindings.
Requires Python: >=3.12

﻿# Python Bindings for Confetti

This repository contains Python bindings for [Confetti](https://github.com/hgs3/confetti).
For a pure Python implementation of Confetti, see [PyConfetti](https://github.com/bobuk/pyconfetti/).

The bindings correspond one-to-one with the Confetti C API whereas the pure Python implementation offers a higher-level interface that deserializes Confetti directly into Python data structures.
The latter is recommended for most use cases.

[![Build Status](https://github.com/hgs3/confetti-python/actions/workflows/build.yml/badge.svg)](https://github.com/hgs3/confetti-python/actions/workflows/build.yml)

## Installation

Install the bindings with

```
$ pip install cconfetti
```

The bindings require you to have a C compiler accessible to Python.

## Complete Example

The following complete Python program reads Confetti source text from standard input and pretty prints it to standard output.

```py
import cconfetti

def print_indent(depth) -> None:
    for i in range(depth):
        print("    ", end="")

def print_directives(directive, depth) -> None:
    print_indent(depth)

    # The directive arguments.
    for index,arg in enumerate(directive.arguments):
        print(arg.value, end=" ")

    # The directive's subdirectives.
    if len(directive.subdirectives) > 0:
        print("{")
        for subdir in directive.subdirectives:
            print_directives(subdir, depth + 1)
        print_indent(depth)
        print("}")
    else:
        print("")

source = input("Enter Confetti: ")
directives = cconfetti.parse(source)
for dir in directives:
    print_directives(dir, 0)
```

## License

MIT License.
pyresolvemetrics 0.3.5
Entity resolution metrics library
Requires Python: <4.0,>=3.12

# PyResolveMetrics

This is a standards compliant ([PEP-544](https://peps.python.org/pep-0544/)) and
efficient library for computing entity resolution metrics.
The library currently supports two ways of modelling entity resolution:

* [Fellegi-Sunter](https://www.tandfonline.com/doi/abs/10.1080/01621459.1969.10501049)
* [algebraic](https://www.igi-global.com/chapter/information-quality-management/23022)

## Set up

This library uses [Poetry](https://python-poetry.org) to manage dependencies and
`make` for build management. Please make sure these tools are installed.

## Run tests

Run the unit tests for this project using `make`.

```shell
$ make test
```

## Usage sample

Sample code that's informative about the library's capabilities
[is available](./sample/sample.py).
Check it out to figure out how the library works.
The [unit tests](./tests/) can also be used as documentation. 

## Paper Citation

This paper was published in the  Proceedings of the 16th International
Conference on Computer Supported Education.

### in Harvard Style
```
Olar A. and Dioşan L. (2024). PyResolveMetrics: A Standards-Compliant and Efficient Approach to Entity Resolution Metrics. In Proceedings of the 16th International Conference on Computer Supported Education - Volume 1: CSEDU; ISBN 978-989-758-697-2, SciTePress, pages 257-263. DOI: 10.5220/0012546300003693
```

### in Bibtex Style
```bibtex
@conference{csedu24,
author={Andrei Olar and Laura Dioşan},
title={PyResolveMetrics: A Standards-Compliant and Efficient Approach to Entity Resolution Metrics},
booktitle={Proceedings of the 16th International Conference on Computer Supported Education - Volume 1: CSEDU},
year={2024},
pages={257-263},
publisher={SciTePress},
organization={INSTICC},
doi={10.5220/0012546300003693},
isbn={978-989-758-697-2},
}
```
pycnnum 2.1.1
Chinese number <=> int/float conversion for Python3.8+
Requires Python: >=3.8

# PyCNNUM

Convert numbers in Chinese string to/from `int`/`float`/`str` for Python3.8+.

[API document](https://zcold.github.io/pycnnum/pycnnum.html)

---

- [1. Install from PyPI](#1-install-from-pypi)
- [2. Install from Source](#2-install-from-source)
- [3. Examples](#3-examples)
- [4. Install Development Packages](#4-install-development-packages)

---

## 1. Install from PyPI

```bash
pip install pycnnum
```

## 2. Install from Source

```bash
# git is required
git clone https://github.com/zcold/pycnnum.git
cd pycnnum
python -m pip install .
```

## 3. Examples

```python

>>> from pycnnum import cn2num, num2cn
>>> cn2num("一百二十三")
123
>>> num2cn(123)
'一百二十三'
>>> cn2num("一兆零四十五", numbering_type="mid")
1000000000045
>>> num2cn(2400, alt_2=True)
'两千四'
>>> num2cn(3.4)
'三点四'

```

## 4. Install Development Packages

```bash
# example for working under Ubuntu 22.4
# git and python3.8-venv are required
git clone https://github.com/zcold/pycnnum.git pycnnum_dev
cd pycnnum_dev
python3.8 -m venv .venv
source .venv/bin/activate
python -m pip install .[dev] -U

```
e-kreta-hun0r 2.0.12
E-Kréta API wrapper
Requires Python: >=3.9
Keywords: API, e-kreta, wrapper

# e-kreta-hunor-2.0

e-kreta-hunor-2.0 is an api wrapper for the e-kreta system

## installation

now available on [PyPI](https://pypi.org/project/e-kreta-hun0r/)

```bash
py -m pip install e-kreta-hun0r
```

## Usage

quick example

```python
import os

from kreta.mobile import endpoints, models
from kreta.idp import Auth_Session

username = os.getenv("username")
pwd = os.getenv("pwd")
institiute_code = os.getenv("institute_code")

with Auth_Session.login(username, pwd, institiute_code) as session:
    response = endpoints.get_notes(session)
    print(response)

    session.refresh() # it's automatically done when needed
  
    response = endpoints.get_device_state(session)
    print(response)
  
    session.invalidate() # invalidates the refresh token so remove if login is saved


```

Reccomended to use `with` context maneger to properly close the connection.

Reccomended to use `session.invalidate()` if the refresh token wont be saved as it is required in the process to revoke it.

`sessiion.refresh()` refreshes the access token. Usually not required as it done automatically when needed.

Important is that for the `institute_code` parameter the second code of the school is needed. 
check your schools id [here](https://intezmenykereso.e-kreta.hu/)

![login_code](https://github.com/hun0r/e-kreta-hun0r-2.0/blob/main/image/README/login_code.png?raw=true)

## Contributing

Pull requests are welcome. For major changes, please open an issue first
to discuss what you would like to change.

tests would be appreaciated

## License

[MIT](https://choosealicense.com/licenses/mit/)
textx-gen-coloring 0.2.0
A syntax highlight generator for textX languages
Requires Python: >=3.5
Keywords: syntax highlighting, language, DSL

# Syntax Highlighting Generator for textX Languages

This project uses [textX](https://github.com/textx/textx) grammar and generates syntax highlighting file for it.

Supported syntax highlighting languages:

- textmate (used by VS Code and [textx-gen-vscode](https://github.com/danixeee/textx-gen-vscode) project)

## CLI Examples

Generate a default syntax highlighting for _workflow_ language:

```bash
textX generate --target textmate ./examples/workflow/workflow.tx --name Workflow
```

Generate a custom syntax highlighting for _workflow_ language:

```bash
textX generate --target textmate ./examples/workflow/workflow.tx --name Workflow --syntax_spec ./examples/workflow/workflow.txcl
```

## Other Notes

Some parts of code are used from [textX-languageserver](https://github.com/textX/textX-languageserver) project.
Schiphol-API 0.0.5
Python API to interact with schiphol endpoints
Requires Python: >=3.10

# Schiphol-API

A simple and lightweight Python client for interacting with the [Schiphol Airport Public Flights API](https://developer.schiphol.nl/).

This package allows you to easily fetch flight, destination, airline, and aircraft type information from Schiphol Airport.

---

## 📦 Installation

Install the package via pip:

```bash
pip install schiphol-api
```

---

## 🚀 Quick Start

```python
from schipholapi import SchipholAPI

# Initialize the API client with your app_id and app_key
api = SchipholAPI(app_id="your_app_id", app_key="your_app_key")

# Fetch a list of flights
flights = api.get_flights(page=0)

# Fetch details for a specific flight
flight_details = api.get_flight(flight_id="your_flight_id")

# Fetch a list of destinations
destinations = api.get_destinations()

# Fetch details for a specific destination
destination_details = api.get_destination(destination_id="your_destination_id")

# Fetch a list of airlines
airlines = api.get_airlines()

# Fetch details for a specific airline
airline_details = api.get_airline(airline_id="your_airline_id")

# Fetch a list of aircraft types
aircraft_types = api.get_aircraft_types()

# Fetch a list of flight IDs
flight_ids = api.get_flight_ids()
```

---

## 🔧 Available Methods

| Method | Description |
|:-------|:------------|
| `get_flights(page=0, include_delays=False, sort_by="scheduleTime")` | Fetch a paginated list of flights |
| `get_flight(flight_id)` | Fetch details about a specific flight |
| `get_destinations(page=0, sort_by="publicName.english")` | Fetch a paginated list of destinations |
| `get_destination(destination_id)` | Fetch details about a specific destination |
| `get_airlines(page=0, sort_by="publicName")` | Fetch a paginated list of airlines |
| `get_airline(airline_id)` | Fetch details about a specific airline |
| `get_aircraft_types(page=0, sort_by="longDescription")` | Fetch a paginated list of aircraft types |
| `get_flight_ids(page=0)` | Fetch a paginated list of flight IDs |

---

## 🔑 Authentication

You need to register for an account at the [Schiphol Developer Center](https://developer.schiphol.nl/) to obtain your:

- `app_id`
- `app_key`

Use these credentials when initializing the `SchipholAPI` client.

---

## ✨ Future Improvements

- Retry mechanism for API failures
- Rate limit handling
- Async support

---

Made with ❤️ for developers using Schiphol's open data

---