semvec/pypi-packages huggingface dataset:
sq-blocks 0.9.4
Blocks provides a simple interface to read, organize, and manipulate structured data in files on local and cloud storage
Keywords: blocks

# Blocks

Blocks provides a simple interface to read, organize, and manipulate structured data in files
on local and cloud storage. See the [documentation](https://sq-blocks.readthedocs.io) for more
information.

    pip install sq-blocks

![blocks](docs/blocks.gif)

## Development

### Setup

To install all dependencies for local development and testing, you can do

    pip install -e .[dev]

### Tests

* `pytest` runs the unit tests

To run them locally:

    pytest

### Continuous Integrations

CI is handled through GitHub Actions, and will run non-GCS tests on 3.6, 3.7, 3.8.
We may add cloud storage tests to CI soon, but for now tests should also be
run locally to confirm that functionality works as well.

### Versions and Tags

Use bumpversion to update the version of the package

    bumpversion [major|minor|patch]

This will increment the version and update it both in `setup.py` and `blocks/__init__.py`.
It will also automatically commit a tag with the corresponding version. You can push this to the repo
with

    git push --tags

### Formatting

We use pre-commit to ensure consistent formatting, to make sure you run the
hooks:

    pre-commit install

### Docs

The docs are generated from the code with
[sphinx](https://www.sphinx-doc.org/en/master/), and can be tested locally:

    cd docs
    make html

## License

Copyright 2018 Square, Inc.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
tyfbaf 0.0.6
tyfbaf
Requires Python: >=3.9

# tyfbaf

![Version](https://img.shields.io/pypi/v/tyfbaf)
![License](https://img.shields.io/pypi/l/tyfbaf)
![Downloads](https://img.shields.io/pypi/dd/tyfbaf)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

**tyfbaf** is a Python package designed for bringing (even) more joy when using the _[SAP® BusinessObjects™ RESTful Web Service SDK](https://help.sap.com/viewer/58f583a7643e48cf944cf554eb961f5b/4.2/en-US)_.

## Install

You can install via PIP: `pip install tyfbaf`

## Basic Usage

First you have to call the setup function to tell **tyfbaf** the name of your server (and optionally your port, if it's differing from 6405):

```python
>>> import tyfbaf
>>> tyfbaf.setup("my-server-name", port=1234)
```

Then **tyfbaf** gives you a get and a post function in the http module. Those functions are specialized for the _SAP® BusinessObjects™ RESTful Web Service SDK_. So you just have to call the desired endpoint, you can pass your token as a parameter, you don't have to set up headers, etc.

```python
>>> import tyfbaf.http
>>> tyfbaf.http.get("/logon/long")
{'password': '', 'clientType': '', 'auth': 'secEnterprise', 'userName': ''}
```

For common cases, **tyfbaf** gives you predefined functions, too. So for example you can request a token like this.

```python
>>> import tyfbaf.token
>>> tyfbaf.token.request("my-username", "my-password123")
my-server-name:6400@{3&2=5595,U3&p=40674.9596541551,Y7&4F=12,U3&63=secEnterprise,0P&66=60,03&68=secEnterprise:my-username,0P&qe=100,U3&vz=SFY6agrLPxpfQBK1ZKYCahEZKCbfsQm7VgWZFiH.RhM,UP
```

## Contributions

_tyfbaf_ neither claims to be complete nor perfect. If you bump into any kind of bug, please let us know by [opening an issue](https://github.com/yveso/tyfbaf/issues/new). If you have an idea for a new feature, please also [open an issue](https://github.com/yveso/tyfbaf/issues/new). So we could work things out and make the world a little, little, tiny bit better. 😎

## Changelog

See [CHANGELOG.md](https://github.com/yveso/tyfbaf/blob/main/CHANGELOG.md) for more information.

## License

Distributed under the MIT License. See [LICENSE](https://github.com/yveso/tyfbaf/blob/main/LICENSE) for more information.

## Copyright

_SAP® BusinessObjects™_ is the trademark or registered trademark of SAP SE or its affiliates in Germany and in several other countries.

**tyfbaf** is not affiliated, associated, authorized, endorsed by or in any way officially connected to SAP SE or an SAP affiliate company.
pygame-builder 0.2.1
A package to build games with ease.
Requires Python: >=3.6

# pygame-builder
 
### Introduction
Use this package to create a game in python in just a few lines of code. Built on top of Pygame, this module is perfect for beginners looking to make their first game. Experts may also find this useful when trying to save time. Enjoy!

### Code Format
```Python
from pygame_builder import Pygame, Element, Image

with Pygame(backgroundImage : Image = image, size : list = [480, 270], windowCaption = "Pygame", fps = 60, backgroundColour : tuple = (0, 0, 0), backgroundMusic : Music = None), backgroundSound = None) as pg:
    element = Element(image : Image, parent, centerPosition = [0, 0], speed = [1, 1])
    pg.add(element)
    pg.loop(lambda : <callable>)
```

### Example
```Python
from pygame_builder import Pygame, Element, Image

ballGif = "/path/to/ball.gif"

def main():
	ball.bouncingAnimation()

with Pygame() as pg:
    ball = Element(Image(ballGif), pg, pg.getScreenCenter(), [2, 2])
    pg.add(ball)
    pg.loop(lambda : main)
```
zwiftpktmon 0.1.0
A Python port of the C# ZwiftPacketMonitor project which monitors Zwift UDP packets
Requires Python: >=3.10

# zwiftpktmon
A Python port of the C# ZwiftPacketMonitor project which monitors Zwift UDP packets.  

This project implements a TCP and UDP packet monitor for the Zwift cycling simulator. It listens for packets on a specific port of a local network adapter, and when found, deserializes the payload and dispatches events that can be consumed by the caller.  It uses the asyncio standard library to allow the packet parsing activities to not interfere with the event consumer.

NOTE: Because this utilizes a network packet capture to intercept the UDP packets, your system may require this code to run using elevated privileges.  This is definitely required on MacOS.

### Requirements ###

- Requires Python version 3.10 or higher

- Uses the project pcapy-ng as its interface to the Pcap-API.  The Pcap-API exists natively on MacOS and Linux but not on Windows.
On Windows, the Npcap packet capture library must be installed.  Npcap is available here: https://npcap.com/dist/npcap-1.60.exe

- The pcapy-ng library is written in Cython at must be compiled for each environment.  Currently, two environments have been pre-compiled and supported: 
   - Windows 10+ (64bit AMD; Intel might work but untested)
   - MacOS 10.13+ (High Sierra)

## Setup ##

pip install zwiftpktmon

There are some example scripts in the .\tests folder:

- test_harness.py: A simple script allowing network selection and event logging.
- test_harness_ui.py: A simple UI based upon PySimpleGui.  To use this you must pip install PySimpleGui first.
parker-motion-ipa-python-driver 0.0.1
parker motion ipa python driver
Requires Python: >=3.6

# About

A Python driver for the "Intelligent Parker Amplifier" or IPA servo drive/controller by Park Motion

Model: IPA04-HC
Product Page: http://www.parkermotion.com/products/Servo_Drive_Controllers__7313__30_32_80_567_29.html

## Setting up a development environment

```bash
# Create virtual enviroment
python -m venv .venv

# Activate virtual environment Unix/MacOs
source .venv/Scripts/activate
# or activate on Windows
.venv\Scripts\activate.bat

# Upgrade pip (depending on the Python version installed, a newly created virtual environment will how have a version of pip that is vastly out of date)
python -m pip install --upgrade pip

# Install required packages
pip install -r requirements.txt
```

## Helpful Resources

### Parker Motion Manager (PPM)

- Location: `/product_materials/Software/Parker Motion Manager Ver 2.2.1050/pmm_installer_2_2_1050.exe`
- Allows you to interact with the rail
- Has useful help documents
  - See "Parameter Reference"
  - C:\Program Files (x86)\Parker Hannifin\Parker Motion Manager\Help Files\Reference Guides.chm
- Parker Motion Manager Guide:
  - \User Guides\ACR_Programmers_Guide.pdf

### Reference IPA Add-on Instructions

- Location: `/product_materials/Software/Add On Instructions v5/IPA_AOI_Rev5.zip/IPA_AOI_v5/EthernetIP_IPA_B.pdf`
- Location: `/product_materials/Software/Add On Instructions v5/IPA_AOI_Rev5.zip/IPA_AOI_v5/Information/IPA Ethernet IP Parameter Mapping.xlsx`
- .L5X files are presumably used with certain PLC software, but there is some useful reference material in the pdfs.

### ComACRServer6 Communications Server

- Location: `/product_materials/Software/ComACRServer6x`
- An automation server that provides communications between ACR controllers and PC software applications
- Includes samples applications in VB.NET, C#, C++ and VB6

### pycomm3 documentation

- https://docs.pycomm3.dev/en/latest/index.html
- Useful pages:
  - https://docs.pycomm3.dev/en/latest/usage/cipdriver.html
  - https://docs.pycomm3.dev/en/latest/examples/generic_messaging_examples.html#generic-messaging
  - https://docs.pycomm3.dev/en/latest/api_reference/data_types.html
asyncio-tcp-messages 0.1.4
A library for developing applications with a message-based protocol on top of TCP based on asyncio.
Requires Python: >=3.10

A library for developing applications with a message-based protocol on top of TCP based on asyncio.Opens the possibility of adding controllers that are responsible for specific commands, the ability to define and validate command arguments.

1. First, you need to create an instance of the App class

   ```
   import asyncio
   from asyncio_tcp_messages import App

   app = App()

   #Your code

   if __name__ == '__main__':
       asyncio.run(app.run())

   ```
2. Here are some usage examples. You can use pydantic BaseModel subclasses for data validation.

   ```
   import asyncio
   from asyncio_tcp_messages import App
   import pydantic

   app = App()


   class Person(pydantic.BaseModel):
       name: str = pydantic.Field(..., min_length=2, max_length=250, description="The person's name must be at least 2 "
                                                                                 "and at most 250 characters")
       age: int = pydantic.Field(..., ge=0, lt=200, description="The person's age must be greater or equal to zero "
                                                                "and lesser than 250")
       funs: list[str] = pydantic.Field(default_factory=list, title="The activities person likes to do")
       salary: int = pydantic.Field(None, gt=0, description="The person's salary must be greater than zero")

       def __str__(self) -> str:
           return f'{self.name} is {self.age} years old with {self.salary}$ salary and favourite activities: {self.funs}'


   @app.command(name='sum')
   async def custom_sum(user_id: int, arg1: int, arg2: int) -> str:
       return str(arg1 + arg2)


   @app.command()
   async def add_person(user_id: int, person: Person):
       people.append(person)


   @app.command()
   async def get_person(user_id: int, name: str) -> str:
       return '\n'.join(str(person) for person in people if person.name == name)


   if __name__ == '__main__':
       asyncio.run(app.run())

   ```
python-nosql-logger 1.1.6
For logging & accessing application data with NoSQL databases (MongoDB & ElasticSearch)
Requires Python: >=3.6, <4
Keywords: logger,django logger,flask logger,nosql logger,mongodb logger,setuptools,development,elasticsearch,elastic search logging

# python-nosql-logger

## Installation steps if using MongoDB

```
  pip install pymongo #"pymongo[srv]" or "pymongo[aws]"
  pip install python-nosql-logger
```

### Initialize
#### For synchronous mongo logger
```
  from pynosql_logger.loggers import MongoLogger

  connection_string = 'your_mongodb_connection_string'
  logger = MongoLogger(connection_string)
```
#### For asynchronous mongo logger
```
  from pynosql_logger.async_loggers import AsyncMongoLogger
  
  connection_string = 'your_mongodb_connection_string'
  logger = AsyncMongoLogger(connection_string)
```

## Installation steps if using ElasticSearch

```
  pip install requests
  pip install python-nosql-logger
```

### Initialize
#### For synchronous elastic logger
```
  from pynosql_logger.loggers import ElasticLogger
  
  elastic_url = 'http://127.0.0.1:9200'
  logger = ElasticLogger(elastic_url)
```
#### For asynchronous elastic logger
```
  from pynosql_logger.async_loggers import AsyncElasticLogger
  
  elastic_url = 'http://127.0.0.1:9200'
  logger = AsyncElasticLogger(elastic_url)
```

### Add Log
```
  req_json = {
      'users': {
          'first_name': 'Hitesh',
          'last_name': 'Mishra',
          'email': 'hiteshmishra708@gmail.com'
      }
  }
  resp = logger.add_log(req_json)
```

### Add Bulk Log
```
  req_json = {
      'users': [{
          'first_name': 'Test',
          'last_name': 'User 1',
          'email': 'testuser1@mailnesia.com'
      }, {
          'first_name': 'Test',
          'last_name': 'User 2',
          'email': 'testuser2@mailnesia.com'
      }]
  }
  resp = logger.add_log(req_json)
```

### Get Log
You can pass mongo query or elastic query to get the logs
```
  req_json = {
      'users': {
        'first_name': 'Hitesh'
      }
  }
  resp = logger.get_log(req_json)
```

### Get All Logs
```
  req_json = {
      'collection': 'users'
  }
  resp = logger.get_all_logs(req_json)
```