semvec/pypi-packages huggingface dataset:
guacamole-api-wrapper 0.1.0
A Python package that allows for simple interactions with Apache Guacamole REST API as a wrapper
Requires Python: >=3.6

# Guacamole Wrapper Package

[![pipeline status](https://gitlab.com/gacybercenter/open/guacamole-api-wrapper/badges/0.0.3/pipeline.svg)](https://gitlab.com/gacybercenter/open/guacamole-api-wrapper/-/commits/0.0.3)



This is a simple package that allows you to take advantage of all
currently available REST API calls within Apache Guacamole.

## Overview

This package creates a class named `session` allowing you to interact
with the REST API for Apache Guacamole in various ways. Full capabilities
include:

- **Generating and Deleting your REST API Auth token**
- **Users & UserGroups**  
    _list, create, update, delete_
- **Connection & ConnectionGroups**  
    _list, create, update, delete_
- **List Schema Info**  
    _list_
- **Sharing Profiles**  
    _list, create, delete_


### Work in Progress

- Code Enhancements
- CI/CD for auto deployment

## Install

```
pip install guacamole-api-wrapper
```

## Usage
The overall usage capabilities of this module are extensive, I would
recommend you leverage a good ide that can show all available functions
and arguments. I tried to ensure each function has a basic comment and
I have tested all functionality, but am always looking for ways to break
it in order to improve it.

**Initial Module Import:**
```
import guacamole
```

Defining session arguments and then list users

**syntax:**  
```
guacamole.session("https://{guacamole_base_url}", "{datasource}", "{username}", "{password}")
```

**example:**
```
session = guacamole.session("https://web.app/guacamole", "mysql", "guacadmin", "guacadmin")

session.list_users()
```
hiddenbot 0.0.3
Dark Web Crawler
Requires Python: >=3.11,<4.0

# HiddenBot

Dark web crawler.

## Prerequisites

### Tor

Access to onion services, we need to use **Tor** proxy.

```sh
# If tor is not installed...
sudo apt install tor

tor &
```

To check if you're using Tor from command line, run the following command:

```sh
curl -fsSL -x socks5://127.0.0.1:9050 check.torproject.org | grep Congratulations
```

If the content "Congratulations. This browser is configured to use Tor." appeared, your Tor proxy configuration is correct.

### Virual Machine (Optional)

It's recommended to use a virtual machine for more securely connecting to dark web.

<br />

## Usage

```sh
hiddenbot run -u https://xxx...xxx.onion/

# Depth (-d)
hiddenbot run -u https://xxx...xxx.onion/ -d 5

# Output (-o)
hiddenbot run -u https://xxx...xxx.onion/ -o result.json
```

- `hiddenbot` currently extracts **title**, **description** and **URL** only.
- Extracted data is saved to a **JSON** file.

<br />

## Installation

### From Pip

```sh
pip install hiddenbot
```

### From Source

```sh
git clone https://github.com/hideckies/hiddenbot.git
cd hiddenbot
poetry install
poetry shell
hiddenbot --help
```
sb-serializer 0.0.3
A json serializer and naming implementation
Requires Python: >=3.7

# My Simple Json Serializer and Naming Utilities

## The main class is the serializer - HardSerializer
It's not particularly hard, just doesn't try to infer the class to deserialize (like my previous iterations), you need to specify the class directly.
Also, it's fairly picky about the format of the class - you need to use typing **EVERYWHERE** or it doesn't work.  It uses a lot of reflection to 
figure stuff out, and the typing is critical.  
  
It can figure out enums, lists, hierarchies, etc.  Pretty powerful.  The json is standard, no tags or anything, and compatible with other languages and libraries
like System.Text.Json in .NET

It essentially converts the object model into dicts and then `json.dumps()` them to serialize, the reverse for deserialize.

### Usage
You need to specify the fields in the class definition as well as in the __init__ - like so:
```
class TestClass(object):
    id: int
    name: str
    guid: uuid.UUID
    test_enum: TestEnum

    def __init__(
        self,
        id: int = 0,
        name: str = "",
        guid: uuid.UUID = uuid.uuid4(),
        test_enum: TestEnum = TestEnum.Undefined,
    ):
        self.id = id
        self.name = name
        self.guid = guid
        self.test_enum = test_enum
```
Note the typing hints everywhere

It can handle hierarchies as long as the type hints are there:
```
class ParentClass(object):
    id: int
    name: str
    guid: uuid.UUID
    test_enum: TestEnum
    children: list[TestClass]

    def __init__(
        self,
        id: int = 0,
        name: str = "",
        guid: uuid.UUID = uuid.uuid4(),
        test_enum: TestEnum = TestEnum.Undefined,
        children: list[TestClass] = [],
    ):
        self.id = id
        self.name = name
        self.guid = guid
        self.test_enum = test_enum
        self.children = children
```

Unit tests are included to see usage, but the basics are:  
```
tc = TestClass(12, "Bob", test_enum=TestEnum.Value1)
json = serializer.serialize(tc)
new_tc = serializer.de_serialize(json, TestClass)
```
It will try to deserialize into the `TestClass`

## Naming
The naming is a bit weirder, and uses custom dictionaries to work - not sure how else to do it.    
The project originated from trying to form decent property names from database fieldnames.  

## Usage
Create the `Naming` class instance from the 2 dictionaries, the standard word list and the bigwords list (specifies common word combinations that are hard to infer)  
Create `Name` class instances by using `naming.string_to_name()`  
The `Name` class instance has different methods on it like `Pascal`, `Snake`, etc.  
Simple.


## Building
`python -m build `

## Deploying
`python -m twine upload --repository pypi dist/*`
pyprocessors-similar_segments 0.5.37
Similar segments processor
Requires Python: >=3.8

## Requirements

- Python 3.8+
- Flit to put Python packages and modules on PyPI
- Pydantic for the data parts.

## Installation
```
pip install flit
pip install pymultirole-plugins
```

## Publish the Python Package to PyPI
- Increment the version of your package in the `__init__.py` file:
```
"""An amazing package!"""

__version__ = 'x.y.z'
```
- Publish
```
flit publish
```
pyprocessors-search_segments 0.5.32
Similar segments processor
Requires Python: >=3.8

## Requirements

- Python 3.8+
- Flit to put Python packages and modules on PyPI
- Pydantic for the data parts.

## Installation
```
pip install flit
pip install pymultirole-plugins
```

## Publish the Python Package to PyPI
- Increment the version of your package in the `__init__.py` file:
```
"""An amazing package!"""

__version__ = 'x.y.z'
```
- Publish
```
flit publish
```