semvec/pypi-packages huggingface dataset:
iams 0.7.10
An industial agent management system aiming to control agents for manufacturing units.
Requires Python: >=3.8

Industrial Agent Management System
==================================

Agent-management system designed for industrial applications.
This repository represents a scalable solution for orchestration and deployment of industrial agents.
It follows the hybrid integration patterns for industrial agents and concists of a server part and client libraries that are used to develop clients.

IAMS Server
-----------

The server needs docker swarm available (on premise) and orchestrates mircoservice applications (the agents) in the cluster.
It used docker images, which can be globally distributed by vendors, to deploy a service managing every machine on the shop floor.
Furthermore, it provides provisioning capabilities, allowing the agents to consume cloud-wide services, like log aggregation or databases.
The agents can request the provisioning via docker labels attached to the image.
The IAMS server will generate neccecary configurations and credentials and provide the agents with the access.

The IAMS server runs with a mandatory certificate authority (CFSSL), which is used to provide every agent with its own client certificate.
All internal cloud communication can be encrypted automatically, and agents could use a access control lists (ACLs) to verify requests.
The idea is to use a graph database (arango-db) to store relationships between agents and use them as ACLs, however an example configuration and implementation is not yet provided.

IAMS Clients
------------

Clients use gRPC for their internal communications. gRPC has some advantages in comparision to OPC-UA - it uses TLS, which ensures smaller response times for persistent connections (after the handshake), and it supports Server Name Indication (SNI) which enables the usage of 3rd party proxy servers (nginx, envoy) to securely expose the service to external applications.

As gRPC is used, the client programming language can be specified by the developing team. However, this project only focusses on python as a programming language and provides only for this lanuage a client implementation and libraries that help developing clients.

Typically an agents connects via a TCP-based communication (OPC-UA, HTTP, Sockets) to a machine and used the machine-specific communication protocol to receive staus updates from the machine.
The status updates are processed by the agent, which then updates it's connected agents with it's changed state.
In addition to agents, that are connected to a physical devices, coordination agents can be used to aggregate and group agents.

Example implementations can be found in the ``examples`` folder of this repository

Contributions
--------------

Feel free to contribute to this repository.

Use the ``Makefile`` (``make build``) to generate a docker image. The build process includes basic software tests.

Help and Support
-----------------

Use github tickes for support.
capsulecorp 0.2.20
General python utilities package for working with public cloud services and big data
Requires Python: >=3.9

# capsulecorp
General python utilities package for working with public cloud services and big data

[![codecov](https://codecov.io/gh/leealessandrini/capsulecorp/branch/main/graph/badge.svg)](https://codecov.io/gh/leealessandrini/capsulecorp)
opentip 1.2
Tools and Python API for accessing Kaspersky OpenTIP
Requires Python: >=3.8

## OpenTIP scanner

The script is a Python 3 client to the [OpenTIP service](https://opentip.kaspersky.com).

It can scan files and directories and provide the category (clean, malware, adware). For unknown files, it will also upload them to the service for scanning and Sandbox processing (optional).

To run the script, you need to obtain a valid API key from [OpenTIP](https://opentip.kaspersky.com/token) and set it with the --apikey command line switch or the OPENTIP\_APIKEY environment variable.

## Building

```
python3 -m build
```

## Installation

Install the package via pip.

```
pip3 install opentip
```


## Command line switches

### OpenTIP file scanner

```
usage: opentip [-h] [--no-upload] [--exclude EXCLUDE] [--log LOG] [--apikey APIKEY] [--quiet] path [path ...]

Check files and directories with OpenTIP.kaspersky.com, optionally upload and scan unknown files

positional arguments:
  path               File or directory location to scan

optional arguments:
  -h, --help         show this help message and exit
  --no-upload        DO NOT upload unknown files to scan with the Sandbox, default behaviour is to upload
  --exclude EXCLUDE  Do not scan or upload the files matching the pattern
  --log LOG          Write results to the log file
  --apikey APIKEY    OpenTIP API key, received from https://opentip.kaspersky.com/token
  --quiet            Do not log clean files
```

### IOC checker

```
usage: check_iocs [-h] [--apikey APIKEY] [--out OUT] type value

Check IOCS (file hashes, IP addresses, domain names, URLs using the service OpenTIP.kaspersky.com

positional arguments:
  type               hash, ip, domain, url
  value              Value of the IOC (hash, ip, domain, url, filename with the iocs)

optional arguments:
  -h, --help         show this help message and exit
  --apikey APIKEY    OpenTIP API key, received from https://opentip.kaspersky.com/token
  --out OUT, -o OUT  Write output as JSON to this filename
```
sphinx_nervproject_theme 3.0.2
A Sphinx-doc theme based on     Vuepress
Requires Python: >=3.8
Keywords: sphinx,doc,theme

Sphinx NervProject Theme
========================

A modern responsive theme for python's `Sphinx <http://www.sphinx-doc.org>`_ documentation generator based on
sphinx_press_theme and ablog.

This theme is based on `VuePress <https://vuepress.vuejs.org/>`_.
It uses `Vue.js <https://vuejs.org/>`_ and LessCSS managed by
`webpack <https://webpack.js.org>`_ through `vue-cli <https://cli.vuejs.org/>`_.


Usage
~~~~~

On Sphinx project's `conf.py`: set the theme name to `nervproject`.

.. code:: python

   html_theme = "nervproject"

See details on `Sphinx theming docs <http://www.sphinx-doc.org/en/master/theming.html#using-a-theme>`_.

Development
~~~~~~~~~~~

To rebuild web assets:

.. code:: bash

   npm run build

Install theme locally with `pip install -e .`.

`docs` folder contains theme's own documentantion.

.. code:: bash

   cd docs
   make clean; make html

Compatibility
~~~~~~~~~~~~~

This theme needs CSS vars enabled in the browser, so
it doesn't work on IE. Four color variations are
available :

- light low contrast (default) ;
- light high contrast ;
- dark low contrast ;
- dark high contrast.

The good one is used based on prefers-contrast and
prefers-color-scheme media queries. This is automatically
done by a compatible browser. If not, the default theme
is used. Some browsers need manual configuration like
Chromium on Linux (a flag to enable for all websites).

Example
~~~~~~~

See the `Nerv Project's web site <https://www.nerv-project.eu>`_
pyucc 1.7
A high level, unoptimized, colored console written in python.

# PyUCC

### An Unoptimezed Console Colorization tool written in python.

## How to Install

This python project was converted to a pypi package, to install this package you can just use [pip](https://pypi.org/project/pip/).

```python
pip install pyucc
```

## Usage

After installing the package with pip, all you need to do is import it like you would any other package and work on colorizing your precious console. This package relies on ANSI Unicode Escape Sequences to allow for coloring in the rgb space inside your console.

```python
from pyucc import console, colors

# Use cprint or colored print just like you would pythons print method.
console.cprint(colors.vibrant_red, "This text is in red")

# You can also use formatting
console.cprint(f"{colors.vibrant_red}This text is also in red")

# Use .switch for background switch
console.cprint(f"{colors.vibrant_red.switch}This text has a red background")
```

> Basic Red Text

There are some more advanced use cases like registering your own console class:

```python
from pyucc import console, colors, symbols

@console.register(identifier="test")
def test(*values, **optional):
  # Optional can be used to access "optional" values like time.
  time = optional.get("time")
  console.cprint(f"{colors.vibrant_purple.switch} Debug {symbols.reset} {colors.chex('#aaaaaa')}{time}{symbols.reset}", *values)

console.test("This is the test method")
```

> Advanced customized console

Also, cprint can be used as print if you need to.

```python
from pyucc import console
console.cprint("This is just a print")
```
secret-message 1.1
Create and share a Message Secretly.


# Secret-Message 
[![PyPI](https://img.shields.io/pypi/v/secret-message?color=blueviolet&label=Web-version%20&logo=appveyor&style=plastic)](https://secret-msg.onrender.com/)

[![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/PurpleBird7613/secret_msg?color=inactive&label=GitHub)](https://github.com/PurpleBird7613/secret_msg)

[![PyPI](https://img.shields.io/pypi/v/secret-message?color=blue&label=python-package&style=plastic)](https://pypi.org/project/secret-message/)

Create and share Messages in a  **Secret** way.

## Install
```python
pip install secret-message
```

## Import the package
```python
import secret_message

# ------OR------

#from secret_message import create,show,history
```

## Create a Message:
```python
import secret_message as message 

message.create("<USERNAME>","<YOUR_MESSAGE>","<Image_Path(Only Image)>" or None,"<PASSWORD_FOR_THE_MESSAGE>")
```
For creating a message it takes only 3 parameters:
```
1. Username - Just add your name as username(No registration stuff is required.)
	
2. Text Message - You can add your message 

3. Image - You can add image as a message, just add image path here or just add None if you don't want to add an image
	
4. Message Password = Create a password of your choice for the message you are creating 
```

• Output:
```python
{
  "id": <YOUR_MESSAGE_ID>,
  "text_message": "<YOUR_MESSAGE>",
  "image": "<YOUR_IMAGE>",
  "password": "<YOUR_MESSAGE_PASSWORD>",
  "web_msg_link": "<YOUR_MESSAGE_LINK_FOR_WEB>",
  "api_msg_link": "<YOUR_MESSAGE_LINK_FOR_API_CALL>"  
}
```
```
web_message_link - Using this link anyone will be able to access your message from web[Any web browser].

api_msg_link - Using this link anyone will be able to access your message by api call 

image - Can only be seen from web_message_link
```

## Show/Read Message
```python
import secret_message as message

message.show("<USERNAME>","<MESSAGE_LINK>","<PASSWORD_OF_THE_MESSAGE>")
```
For showing or reading someone else's messages,it takes only 3 parameters:
```
1. Username - Just add your name as username(No registration stuff is required.)
	
2. Message Link - This link must the "api_msg_link" in order to read or view the message.
	
3. Password - This must be the exact password for the message created by other user.
```
	
• Output:
```python
{
  "text_message" : "<USER'S_MESSAGE>",
  "image" : "<USER'S_IMAGE>",
  "web_msg_link" : "<USER'S_MESSAGE_LINK_FFOR_WEB>"
}
```

## Message History 
```python
import secret_message as message

message.history("<Username>")
```
For getting history of your messages,it takes only 1 parameter:
```
1. Username - Just add your name as username(No registration stuff is required.)
```

• Output:
```python
{
  "Messages": [
  	{
  	   "id": "<YOUR_MESSAGE_ID>",
  	   "text_message": "<YOUR_MESSAGE>",
  	   "image": "<YOUR_IMAGE>",
  	   "password": "<YOUR_MESSAGE_PASSWORD>",
  	   "web_msg_link": "<YOUR_MESSAGE_LINK_FOR_WEB>",
  	   "api_msg_link": "<YOUR_MESSAGE_LINK_FOR_API_CALL>" 
  	},
  	........,
  ]
}
```
SimpleCache2 1.2.1
Cache system for python

# SimpleCache

## Usage

```python
from SimpleCache2 import simple_cache
from SimpleCache2.FileCache import FileCache
from SimpleCache2.MemoryCache import MemoryCache
from SimpleCache2.Settings import Settings

# save cache in python variable 
memory = MemoryCache()
# save cache in one json file 
settings = Settings(settings_file="path/to/test.json")
# save cache in many binary files
cache = FileCache(cache_dir=None)


# Usage as decorator
@simple_cache(cache, ttl=10, key_prefix="test_")
def testFunc(name):
    return f"hello world {name}"


# Usage as callback
cache.call(["cache key can be any value"], 10, testFunc, "Bob")

# Usage as functional
cache.set("key", "value")  # self
cache.get("key")  # value
cache.exist("key")  # bool
cache.delete("key")  # bool
cache.clearOld()  # bool
```

## Api

You can write you self cache class:

```python
from SimpleCache2.CacheSystem import CacheSystem


class MyCacheClass(CacheSystem):
    def exist(self, key: any) -> bool:
        pass

    def get(self, key: any) -> any:
        pass

    def set(self, key: any, value: object, ttl: int = 0) -> object:
        return self
        pass

    def delete(self, key: any) -> bool:
        pass

    def clearOld(self):
        pass
```
evm-architect 1.0.0
Get the entire architecture of a smart contract system from any address in the architecture
Requires Python: >=3.9,<3.10

# EVM_Architect
There's a handful of optimizations still to be had. Speed has been increased by using a rpc provider rather than etherscan for getCode, and the multicheck function is now multithreaded so that all the checks occur simultaneaously. The following is an example of how to get a flat list of entities in an architecture, given a single address.

To use this, make sure you're using python 3.9.0. You can install using pip.

```Python
pip install evm-architect
```

Most of the time you'll probably just want to use getArch(), these are the arguments:

```Python
getArch(
    address-string, 
    transaction_limit-int, 
    flatten-bool)
```

If flatten==True, then you will get a list of addresses (EOAs and contracts).

```Python
#Example:
['0xd1c24f50d05946b3fabefbae3cd0a7e9938c63f2', '0xc0a47dfe034b400b47bdad5fecda2621de6c4d95', '0xa087b7351c24082ac7ef7ca79b4f4c5d2e82be84', '0x2157a7894439191e520825fe9399ab8655e0f708', '0x2c4bd064b998838076fa341a83d007fc2fa50957', '0xddee242662323a3cff3f9aa139ffa496ac3c73b0',...]
```

If flatten==False, then you will get a dictionnary in the format below. Keep in mind that created1 may also be a creator somewhere else in the dictionnary.

```Python
{creator:[created1,created2,created3,...]}
#Example:
{'0xd1c24f50d05946b3fabefbae3cd0a7e9938c63f2': ['0xa087b7351c24082ac7ef7ca79b4f4c5d2e82be84', '0x2157a7894439191e520825fe9399ab8655e0f708', '0xc0a47dfe034b400b47bdad5fecda2621de6c4d95'],...}
```

Here are some code examples:


```Python
from evm_architect import architect

arch=architect.Arch()

architecture=arch.getArch("0xc0a47dFe034B400B47bDaD5FecDa2621de6c4d95",50,False)

architecture=arch.getArch("0xc0a47dFe034B400B47bDaD5FecDa2621de6c4d95",50,True)

uarch=arch.uniqueContracts(architecture,{})
#returns a dictionary of {address: hash of opcode stack} using every address in the creationdict (unflattened architecture)

highest=arch.getHighest(architecture)
#returns the highest position creator in the creationdict (unflattened architecture)
```