semvec/pypi-packages huggingface dataset:
iksemel 1.6.2
This is an XML parser library mainly designed for Jabber applications.
Requires Python: >=3.7

[![Issues](https://img.shields.io/github/issues-raw/Zaryob/iksemel?style=for-the-badge)](https://github.com/Zaryob/iksemel/issues) [![PullRequests](https://img.shields.io/github/issues-pr-raw/Zaryob/iksemel?style=for-the-badge)](https://github.com/Zaryob/iksemel/pulls)

[![Travis Status](https://travis-ci.org/Zaryob/iksemel.svg?branch=master)](https://travis-ci.org/Zaryob/iksemel) ![Language](https://img.shields.io/badge/language-c-blue.svg) ![License](https://img.shields.io/badge/license-LGPL2-purple.svg) [![Document](https://img.shields.io/badge/document-gh--pages-blue)](https://zaryob.github.io/iksemels)

                      iksemel 1.6.2

            http://code.google.com/p/iksemel

      Owner:
      Copyright (c) 2000-2011 Gurer Ozen <meduketto at gmail.com>

      Changes and maintenance:
      Copyright (c) 2016-2024 Suleyman Poyraz <zaryob.dev at gmail.com>

Introduction:
-------------

This is an XML parser library mainly designed for Jabber applications.
It provides SAX, DOM, and special Jabber stream APIs. Library is coded
in ANSI C except the network code (which is POSIX compatible), thus
highly portable. Iksemel is released under GNU Lesser General Public
License. A copy of the license is included in the COPYING file.


Requirements:
-------------

Meson and Ninja packages are required for compiling cvs versions.

TLS support requires OpenSSL (>1.1.0) or GNUTLS (>2.0.0) library.

Python bindings requires Python (>3.3).


Compiling & Install:
--------------------

If you got the source from CVS, type
```bash
  meson build
```
for creating configuration script and files.

Then type
```bash
  ninja -C build
```
now library is compiled. You can test it with
```bash
  ninja test -C build
```
and install it with

  (become root if necessary)
```bash
  ninja install -C build
```

Parameters
----------

* **openssl**: [enabled,disabled] OpenSSL support. (Conflicts with GNUTLS)
* **gnutls**: [enabled,disabled] GNUTLS support. (Conflicts with OpenSSL)
* **with_tools**: [true,false] Enable Tools (hash, ikslint, iksperf, iksroster)
* **with_python**: [true,false] Enable Python support.
py-mecs 0.1.1
A pythonic event driven entity component system
Requires Python: >=3.8

# Mecs
## An ecs implementation for game development in python
- implementation focusing on basic data structures and functions
- intuitive api with minimal boilerplate and fast startup
- easy to understand src code, with a focus on simplicity and readability
- built as a simple implementation of ecs
- generic api, allowing use in game dev, app dev, or other applications
---

## Installation
the easiest way to get up and running is to start you vm of choice and then to use pip
  
```
pip install py-mecs
```

it can then be imported using the library name under whatever alias you want

```py
import mecs as engine
```

## Features
- [x] Entity creation/deletion
- [x] Component attachment/detachment
- [x] Templates
- [x] Entity handle class
- [x] single/multi component queries
- [ ] relationships
- [ ] tags
- [x] system schedule
- [x] custom scheduling
- [ ] async scheduling
gptdb-tugraph-plugins 0.1.0
TuGraph plugins python package used in GPT-DB.
Requires Python: >=3.8
Keywords: TuGraph GPT-DB graph LLM

# gptdb-tugraph-plugins

TuGraph plugins python package used in GPT-DB.

## Why this repository?

TuGraph plugins are written in cpp and are compiled into dynamic link libraries. The purpose of this repository is to package these plugins into a python package so that they can be easily installed and used in GPT-DB.


## How to use in python?

1. First install the package using pip:

```bash
pip install gptdb-tugraph-plugins>=0.1.0rc1 -U -i https://pypi.org/simple
```

2. Then you can use the plugins in python:

```python
from gptdb_tugraph_plugins import get_plugin_binary_path

leiden_bin_abs_path = get_plugin_binary_path("leiden") 

print(leiden_bin_abs_path)
```

You will get the absolute path to the leiden plugin binary file.


## How to build the package?

```bash
BUILD_VERSION=0.1.0rc1 make py-package
```

The package will be built in the `python/dist` directory.
nfttools 0.1.2
help interacting with nftables
Requires Python: >=3.7
Keywords: nftables validation parsing

# NftTools

Help interacting with nftables

NftTools provides helpers to work with nftables from Python. It builds on python-nftables which itself uses libnftables. Note that the API is not yet stable and can change from one version to the next.

---

## Features

- Convert an nftables rule into its JSON representation.
- Validate an nftables rule by temporary applying it in a helper chain.
- Convert simple rules into a dictionary representation.
- Convert that dictionary representation into an nftables rule.
- Supports IPv4 and IPv6.
- Provides limited support for sets.

---

## Installation

Install using PyPi:

```shell
pip3 install nfttools
```

Note: The tool uses `python3-nftables` as dependency. If you don't use Debian's operating system package (or Alpine's `py3-nftables`) but attempt to install `pip-nftables` instead, the latter might complain on missing "schema.json". Workaround: Use the operating system package or copy it's "schema.json" to the place `pip-nftables` is looking for that file.

---

## Reporting bugs

In case you encounter any bugs, please report the expected behavior and the actual behavior so that the issue can be reproduced and fixed.

---
## Developers

### Clone repository

Clone this repo to your local machine using `https://github.com/towalink/nfttools.git`

Install the module temporarily to make it available in your Python installation:
```shell
pip3 install -e <path to root of "src" directory>
```

---

## License

[![License](http://img.shields.io/:license-mit-blue.svg?style=flat-square)](https://opensource.org/licenses/MIT)

- **[MIT license](https://opensource.org/licenses/MIT)**
- Copyright 2024 © <a href="https://github.com/towalink/nfttools" target="_blank">Dirk Henrici</a>.
pacote-matrizes 0.0.1
A package for summing rows and columns in Pandas DataFrames
Requires Python: >=3.6

# pacote_matrizes

This Python package provides two simple functions for calculating the sum of numbers in a Pandas DataFrame, either by column or by row.

## Features

- **`sum_column(matrix, column_index)`**: Calculates the sum of numbers in the column at the specified index.
- **`sum_row(matrix, row_index)`**: Calculates the sum of numbers in the row at the specified index.

## Installation

To install this package locally, clone the repository and run the following command in the package root directory (where `setup.py` is located):

```bash
pip install .
```
run-with-logger 1.0.0
Like `subprocess.run`, but with the ability to pipe `stdout` and/or `stderr` to a `Logger` or capture each stream independently while the process is running.
Requires Python: >=3.11

# run_with_logger

Like `subprocess.run`, but with the ability to pipe `stdout` and/or `stderr` to a `Logger` or capture each stream
independently while the process is running.

## Examples

### Log `stderr` and capture `stdout`

The main process will wait for the subprocess while:
- forwarding `stderr` line by line to the logger
- capturing `stdout` in a `CompletedProcess` object, which is returned when the process finishes
 
```python
from run_with_logger import run_with_logger
from logging import getLogger

logger = getLogger(__name__)

completed = run_with_logger(
    args=['foo', 'bar'],
    logger=logger,
    stdout_action="capture",
    stderr_action="log",
    check=False,
)

print(completed.stdout)
```

### Log `stdout` and discard `stderr`

The main process will wait for the subprocess while:
- forwarding `stdout` line by line to the logger
- discarding `stderr`
 
```python
from run_with_logger import run_with_logger
from logging import getLogger

logger = getLogger(__name__)

completed = run_with_logger(
    args=['foo', 'bar'],
    logger=logger,
    stdout_action="log",
    stderr_action="discard",
    check=False,
)

print(completed.stdout)
```
langchain-search1api 0.1.0
LangChain tools for the search1api service
Requires Python: >=3.8

# LangChain Search1API Tools

This package provides LangChain tools for the [Search1API](https://www.search1api.com/) service, allowing easy integration of web search, news search, and web crawling capabilities into your LangChain applications.


**Disclaimer:** The author of this package is not affiliated, associated, authorized, endorsed by, or in any way officially connected with Search1API, or any of its subsidiaries or its affiliates. The official Search1API website can be found at [https://www.search1api.com/](https://www.search1api.com/).


## Installation

You can install the package using pip:

```
pip install langchain_search1api
```

## Usage

Here's an example of how to use the tools in a LangChain application:

```python
from langchain_search1api import SearchTool, NewsTool, CrawlTool
from langchain.agents import initialize_agent, AgentType
from langchain.llms import OpenAI

# Initialize the tools
api_key = "your_api_key_here"
search_tool = SearchTool(api_key=api_key)
news_tool = NewsTool(api_key=api_key)
crawl_tool = CrawlTool(api_key=api_key)

# Initialize the language model
llm = OpenAI(temperature=0)

# Create the agent
agent = initialize_agent(
    tools=[search_tool, news_tool, crawl_tool],
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

# Use the agent
result = agent.run("Search for recent news about artificial intelligence and summarize the top 3 results.")
print(result)
```

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
cykooz.rehash 1.0.1
A resumable implementation of SHA1 hasher
Requires Python: >=3.8
Keywords: sha1, resumable

# cykooz.rehash

`cykooz.rehash` is a resumable implementation of SHA1 hasher.

Usage example:

```python
from cykooz.rehash import Sha1


hasher = Sha1()
hasher.update(b'x' * 78)
hasher_state = hasher.serialize()
assert len(hasher_state) == 94
hasher.update(b'x' * 41)
assert hasher.hexdigest() == '4300320394f7ee239bcdce7d3b8bcee173a0cd5c'

new_hasher = Sha1.deserialize(hasher_state)
new_hasher.update(b'x' * 41)
assert new_hasher.hexdigest() == '4300320394f7ee239bcdce7d3b8bcee173a0cd5c'
```
forest-visualization 0.1.3
A Python package for forest structure visualization and traversals
Requires Python: >=3.6

# Forest Visualizer

`forest-visualizer` is a Python package that provides tools for building and visualizing forest data structures using Turtle Graphics. This package allows users to perform operations like inserting nodes, tree traversal (pre-order, post-order, and level-order), deleting nodes, and drawing the forest structure visually.

## Background
This package implements a forest visualization algorithm based on the paper [Novel Static Multi-Layer Forest Approach and Its Applications](https://www.mdpi.com/2227-7390/9/21/2650)   published in MDPI. The paper provides detailed insights into the theoretical foundations of the algorithm.

## Features

- **Tree Insertion:** Insert parent-child relationships to build a forest structure.
- **Tree Traversal:** Perform pre-order, post-order, and level-order traversals of the forest.
- **Node Deletion:** Remove nodes and automatically adjust the tree structure.
- **Visual Representation:** Use Turtle Graphics to draw the forest with customizable node sizes and gaps.
- **Path Finding:** Find the path from any node to the root.

## Installation

You can install the `forest-visualizer` package directly from PyPI:

```bash
pip install forest-visualizer
```
## Example  Python Code

```python
from forest_visualizer import Forest
# Example usage
forest = Forest()

# Inserting nodes
forest.insert('40', 'N/A')
forest.insert('50', '40')
forest.insert('30', '40')
forest.insert('35', '30')
forest.insert('25', '30')
forest.insert('28', '25')
forest.insert('15', '25')
forest.insert('60', '50')
forest.insert('45', '50')
forest.insert('70', '60')
forest.insert('55', '60')


forest.level_traversal()
forest.display()
print(forest.find_parent('25'))
print(forest.find_path_to_root('15'))
#Perform pre-order traversal and print the result
pre_order_result = forest.pre_order_traversal('40')
print("Pre-order traversal result:", pre_order_result)

#Perform pre-order traversal and print the result
post_order_result = forest.post_order_traversal('40')
print("Post-order traversal result:", post_order_result)
forest.draw_tree()
forest.delete_node('25')
forest.draw_tree()
forest.insert('90', '35')
forest.draw_tree()
```
## Output File![enter image description here](https://github.com/ganeshb15/forest-visualization/blob/main/two_circles.png?raw=true)
sqlalchemy-mutables 0.3.1
Nested mutable SQLAlchemy types. Includes JSON (RFC 7159).
Requires Python: >=3.9

# sqlalchemy-mutables

A minimal package for nested mutable datatypes in SQLAlchemy. Main feature is a JSON field that is RFC-7159 compliant.

Developed for SQLAlchemy `v1.3.24`. Your mileage may very with other versions.

## Installation
```
$ pip install sqlalchemy-mutables
```

## Usage

```
from sqlalchemy_mutables import NestedMutableListColumn

class MyTable(Base):
    mutable_list = Column(NestedMutableListColumn)
```

```
from sqlalchemy_mutables import NestedMutableDictColumn

class MyTable(Base):
    mutable_dict = Column(NestedMutableDictColumn)
```

### JSON
To be compliant with RFC-7159, 'primitives' need to be supported as top level 
values. These are values of type `str|int|float|bool` or `None`. Unfortunately, 
these types break SQLAlchemy `Mutable` functionality 
(specifically `bool` as this cannot be subclassed). To allow for these
while maintaining mutable functionality for `list` and `dict`, a wrapper class
has to be used via a `hybrid_property`.

```
from sqlalchemy_mutables import NestedMutableJSONColumn, NestedMutableJSONProperty

class MyTable(Base):
    _mutable_json = Column("mutable_json", NestedMutableJSONColumn)
    mutable_json = NestedMutableJSONProperty("_mutable_json")
```

It is possible to pass a custom functionality to the `getter` and/or `setter`:

```
def json_getter(value):
    if isinstance(value, (int, float)):
        value = value * 2
    return value

def json_setter(value):
    if isinstance(value, (int, float)):
        value = value / 2
    return value

class MyTable(Base):
    ...
    mutable_json = NestedMutableJSONProperty(
        "_mutable_json",
        fget=json_getter,
        fset=json_setter,
    )
```

Passed functions are executed in the existing `getter` and `setter` in the form of
`value = fc(value)`.