semvec/pypi-packages huggingface dataset:
minidir 0.1.3
Minimal directory interface and some implementations
Requires Python: >=3.7
Keywords: directory, fake, filesystem, testing

# minidir: Minimal directory interface and implementation

The minimal interface for directories and files and
two implementations: in-memory and real file system versions.

It's a good choice when we want to separate file-access side effects from
pure functional part of our code base.

## Installation

Already published on Pypi

```shell
pip install minidir
```

## Usage

- Interface: `Directory` -> `Path`, `File`
    - `Directory` is the container where we access `File` by `Path`
- Implementation
    - `SystemDirectory`: a `Directory` backed by real file system.
    - `FakeDirectory`: a `Directory` only exists in-memory.

Some error like `NameCollision` and `NotFound` will be raised in corresponding situations.

Example:

```python
import minidir

class SomeClass:
    folder: minidir.Directory

    def __init__(self, folder: minidir.Directory) -> None:
        # inject directory to separate side effect from core logic
        pass

def main():
    # use actual file system during production
    instance = SomeClass(minidir.SystemDirectory("/path/to/root"))

def test_some_class():
    # use in-memory implementation during test
    instance = SomeClass(minidir.FakeDirectory())
```

## Future Work

- Implementations for network-oriented storage, e.g. WebDAV, S3, Dropbox ...
- Stream based file read / write interface.
obsn 1.0.2
Making Geometry Dash tool development easier in Python.
Requires Python: >=3.8

# ObsidianPy (obsn)

ObsidianPy is a library for Python that provides easier access to Geometry Dash, Encryptions relating to Geometry Dash functions and other utilities. Made mainly for obsidian tools.  
https://sevenworks.eu.org/obsidian

## Installation

You can install the package via pip:

```sh
pip install obsn
```

## Usage

### Importing the Library

```py
import obsidian
```

### Functions

#### Encryption/Decryption and Generation

- `xor_cipher(data, key)`

  Encrypt something with XOR.

  ```python
  x = obsidian.xor_cipher("hello there", "key")
  ```

- `base64_encode(string)`

  Encode a string in Base64.

  ```python
  b64 = obsidian.base64_encode("hello")
  ```

- `base64_decode(encoded_string)`

  Decode a Base64 string.

  ```python
  b64d = obsidian.base64_decode(b64)
  ```

- `gjp_encrypt(data)`

  Encrypt data using GJP (Geometry Jump Password) encryption.

  ```python
  password = obsidian.gjp_encrypt("data")
  ```

- `gjp_decrypt(encrypted_data)`

  Decrypt data using GJP decryption.

  ```python
  passwordyay = obsidian.gjp_decrypt(password)
  ```

- `generate_udid()`

  Generate a UDID for server requests.

  ```python
  udid = obsidian.generate_udid()
  ```

- `generate_rs(n)`

  Generate a random string, RobTops security in a nutshell.

  ```python
  gd_rs = obsidian.generate_rs(8)
  ```

- `generate_uuid(parts=[8, 4, 4, 4, 10])`

  Generate a UUID for server requests.

  ```python
  uuid = obsidian.generate_uuid()
  ```

- `generate_upload_seed(data, chars=50)`

  Generate an upload seed.

  ```python
  upload_seed = obsidian.generate_upload_seed("some data")
  ```

- `generate_leaderboard_seed(jumps, percentage, seconds, has_played=True)`

  Generate a leaderboard seed.

  ```python
  leaderboard_seed = obsidian.generate_leaderboard_seed(10, 80, 120)
  ```

- `generate_chk(values=[], key="", salt="")`

  Generate a fancy CHK.

  ```python
  chk = obsidian.generate_chk([1, 2, 3], key="key", salt="salt")
  ```

#### HTTP Requests

- `gd(endpoint, **data)`

  Send a POST request to the Geometry Dash servers. ("using accounts/registerGJAccount.php" is valid too)

  ```python
  response = obsidian.gd("getGJGirlfriends24", user="Sevenworks")
  ```

- `gdbrowser(endpoint, value, **kwargs)`

  Send a GET request to retrive something from GDBrowser API.

  ```python
  response = obsidian.gdbrowser("search", "*", count=10)
  ```

- `gd2json(response)`

  Convert a Geometry Dash server response (key:value:key:value) to JSON format, for nerds only.

  ```python
  response_json = obsidian.gd_json(response)
  ```

#### Other

- `toast(title, content, timeout=3)`

  Display a toast notification on Windows.

  ```python
  obsidian.toast("My Tool", "yo wassup", timeout=5)
  ```
happyrobot 0.2.9
This package lets you interact with Happyrobot directly from Python.
Requires Python: >=3.9
Keywords: happyrobot

# Happyrobot Python SDK

## Installation

```bash
pip install happyrobot
```


=======
History
=======

0.1.0 (2024-03-11)
------------------

* First release on PyPI.
hamiltoncurrentweather-Rx168059 0.1.2
This package will get information about current weather in hamilton from weatherwatch website
Requires Python: >=3.12

# Hamilton-Current-Weather
This package will get information about current weather in hamilton from weatherwatch website

## How It Works
This package will scrap data from [weatherwatch](https://www.weatherwatch.co.nz/forecasts/Hamilton) to get information about current weather in hamilton

This package used BeautifulSoup4 and Requests to generate JSON output that'll be used for web or mobile apps

## How to Run
```
import hamiltoncurrentweather as hct

if __name__ == '__main__':
    hamilton_weather = hct.CurrentWeather('https://www.weatherwatch.co.nz/forecasts/Hamilton')
    print('main app')
    print(f'description: {hamilton_weather.description}')
    hamilton_weather.run()
```

# Author
Muhammad Dwi Reza
indonesia-latestearthquake-Rx168059 2024.0.0.7
This package will get information about latest earthquake from BMKG(Indonesian Agency for Meteorological, Climatological and Geophysics)
Requires Python: >=3.12

# IndonesiaLatestEarthQuake
This package will get information about latest earthquake from BMKG(Indonesian Agency for Meteorological, Climatological and Geophysics)

## How It Works
This package will scrap data from [BMKG](https://www.bmkg.go.id/) to get information about latest earthquake on indonesia

This package used BeautifulSoup4 and Requests to generate JSON output that'll be used for web or mobile apps

## How to Run
```
import gempaTerkini as gt

if __name__ == '__main__':
    print('Aplikasi utama')

    id_earthquake = gt.GempaTerkini('https://www.bmkg.go.id/')
    id_earthquake.show_description()
    id_earthquake.run()
```

# Author
Muhammad Dwi Reza
stldim 0.4.2
Get dimensions of an STL file
Requires Python: >=3.8

# stldim

A tool for mesuring the dimensions of an STL file.

## Description

This is a python library which measures the dimmensions and coordinates of an STL file. It can be used as a library where you can use the measurements in your code, or it can be used as a command line tool which prints out the measurements as OpenSCAD code, so you can use it as a library in your OpenSCAD designs.

## Acknowledgements

It is an enhanced version of <https://github.com/lar3ry/OpenSCAD---Move-STL-to-origin> which in turn is based on `stldim.py`, by Jamie Bainbridge. Their version can be found at:
  <https://www.reddit.com/r/3Dprinting/comments/7ehlfc/python_script_to_find_stl_dimensions/>

## CLI

If called from the command line, a library is printed to the terminal which can be used in OpenSCAD.

The script will create an OpenSCAD library which will allow you to place an STL file to 6 different positions in relation to the origin:

CTR put's the center of the STL to the origin of the OpenSCAD coordinate system.
CTRXY puts the center of the STL to the origin of the OpenSCAD coordinate system, but only in the XY plane.
NE, NW, SW, SE put the STL to the origin of the OpenSCAD coordinate system, but only in the XY plane, and in the direction of the compass point.

In the generated library, a module `<name>_obj2origin()` is created which you can use to place the object.
Name is derived from the basename of the STL file, with all non-alphanumeric characters replaced by underscores (e.g. `My Object.stl` becomes `My_Object_stl`).

The script will also define variables for the x-, y-, and z-size and -position of the object which can be used for other calculations in your code.

### Usage

```shell
stldim 3DBenchy.stl --name=object >benchy.scad
```

This will create an OpenSCAD library file `benchy.scad` which you can include in your OpenSCAD code:

```OpenSCAD
include<benchy.scad>; // Include the generated library

bin_obj2origin(NE); // put the object in the North-East corner of the XY plane
```

Other options for obj2origin() are:

- `CTR` - Center the object on the origin
- `CTRXY` - Center the object on the origin, but only in the XY plane
- `NE` - Put the object in the North-East corner of the XY plane
- `NW` - Put the object in the North-West corner of the XY plane
- `SW` - Put the object in the South-West corner of the XY plane
- `SE` - Put the object in the South-East corner of the XY plane

## Library

You can also import stldim in your python project and use the provided methods to get the dimensions of an STL file.

Be aware though, that this library is in a very early stage of development and the API might change significantly in the future.


## Prerequisites

You will have to install `stl`, `numpy`, and `numpy-stl` Python packages in case you don't have those already.

```shell
pip3 install stl
pip3 install numpy
pip3 install numpy-stl
```

## Installation

```shell
pip3 install stldim
```
fftwb 0.1.1
The bindings for the C++ backtesting engine.
Requires Python: >=3.11

# Building the Bindings

To build and make the bindings, ensure you have CMake installed. Then, follow the instructions below.

_Python configuration:_

```bash
sudo apt-get update
sudo apt-get install python3.11-dev
python3.11 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
```

_Build commands:_

```bash
mkdir build
cd build
cmake -S .. -B .
make -j
```

Then, run the tests: `./test/tw-test`.

Finally, ensure that there exists a `twb.cpython-39-x86_64-linux-gnu.so` file in the build
directory.

# The FlatBuffer Compiler

## Building

1. Download CMake: https://cmake.org/download/
2. Install CMake:

```bash
tar -zxvf cmake-<version>.tar.gz
cd cmake-<version>
./bootstrap
make -j
sudo make install
cd ..
sudo rm -r cmake-<version>
```

3. Test installation: `cmake --version`
4. Install the FlatBuffers compiler (ensure the version matches the one in the CMakeLists.txt file):

```bash
git clone https://github.com/google/flatbuffers.git
cd flatbuffers
git checkout <version>
cmake -G "Unix Makefiles"
make -j
sudo make install
cd ..
sudo rm -r flatbuffers
```

5. Test installation: `flatc --version`

## Usage

`flatc --language -o output-directory flatbuffer-file.fbs`

_--language specifies the language to compile the schema for. E.g. --cpp, --js, --ts, --python, etc._
blockeng-lasertune 0.0.1
A Python API for the Block Engineering LaserTune Widely Table QCL software development kit (SDK).
Requires Python: >=3.9

# blockeng-lasertune
A Python API for the Block Engineering LaserTune Widely Table QCL software development kit (SDK).

## Overview
The source code and example scripts have been tested using Python 3 running in Windows 10.

1. Project Homepage: https://github.com/houlihaj/blockeng-lasertune
1. Download Page:

## Requirements

## Installation
1. `pip install blockeng-lasertune`

## Usage
There are a number of examples in the `examples` directory that can help you get up and running.
aswan 0.5.15
Data collection manager
Requires Python: >=3.10

# aswan

[![Documentation Status](https://readthedocs.org/projects/aswan/badge/?version=latest)](https://aswan.readthedocs.io/en/latest)
[![codeclimate](https://img.shields.io/codeclimate/maintainability/endremborza/aswan.svg)](https://codeclimate.com/github/endremborza/aswan)
[![codecov](https://img.shields.io/codecov/c/github/endremborza/aswan)](https://codecov.io/gh/endremborza/aswan)
[![pypi](https://img.shields.io/pypi/v/aswan.svg)](https://pypi.org/project/aswan/)
[![DOI](https://zenodo.org/badge/doi/10.5281/zenodo.7477587.svg)](https://doi.org/10.5281/zenodo.7477587)

collect and organize data into a T1 data depot 
named after the [Aswan Dam](https://en.wikipedia.org/wiki/Aswan_Dam)

Collect and compress data from the internet for later parsing

- quick, parallel, customizable to collect
- compressed to store
- quick to sync with a remote store
  - sync to continue collecting
  - sync to parse  
- immutable collection

## To Setup a Remote

set the environment variables `ASWAN_AUTH_HEX` and `ASWAN_AUTH_PASS` according to the [zimmauth](https://github.com/endremborza/zimmauth) package, and `ASWAN_REMOTE` with the name of the default remote.

## Concepts

- objects
  - saved by collection events
- events
  - collection
  - registration (v2: registration for parsing)
  - (v2) parsing
- runs
  - manual run vs automated run
    - makes manual adding of urls easy but revertible
  - has unique id
  - generates events
  - linked to a specific version of the code
    - ideally commit hash + pip freeze
- statuses
  - determined by base status + runs integrated
  - contains
    - what urls need to be collected
    - (v2) what collected objects need to be parsed
  - sqlite file, constantly trimmed

### Structure

- objects
  - 00, 01, ...
- runs
  - run-hash
      - context.yaml
        - commit-hash, pip-freeze, ...
      - events.zip
- statuses
  - status-hash
    - context.yaml
      - parent-status, integrated
    - db.sqlite.zip
- current-run
  - context.yaml
  - events
    - these to be compressed into ../runs
  - status.sqlite

- there is a 'TEST' status
  - cannot be integrated whatever is based on it
  - a test run can be made on it...


when starting a run:
  - check if current-run is empty
    - if not, fail with 
  - find latest status
    - if it has not integrated all past runs, create a new status that has
  - start collection (+ registration)
  - either stops or breaks, all events and objects are saved to disk
  - if properly stops, move and compress stuff
    - based on one that was the starter, and current run id


## Pre v1.0 laundry list

- parallelize push / pull
- parsing/connection/broken session error docs
- transferring / ignoring cookies


- template projects
  - oddsportal
    - updating thingy, based on latest match in season
  - footy
  - rotten
  - boxoffice
MINITRONCONTROL 0.1.0
A Python library to control a four-wheel rover via HTTP requests
Requires Python: >=3.6

# MinitronControl

AN OPEN SOURCE ROVER MINITRON CONTROLER DEVOLOPED BY KRL


## CONTROLES

1. MUST PASS TWO PARAMETERS DIRECTION AND SPEED
2. THE ON BORD ESP'S BLUE LED WILL START BLINKING ONCE THE WIFI IS CONNECTED
3. AND UPON RECIVING A VALID COMMAND THE BLUE LED WILL START BLINKING
4. MAKE SURE THAT YOU MENTION THE CORRECT TARGET IP OF THE ROVER
5. WIFI CREDENTIALS ARE MENTIONED ON THE ROVER






## Installation

```bash
pip install minitroncontrol