semvec/pypi-packages huggingface dataset:
drf-zettabyte 0.0.1b0
Simple yet powerful implementations that are used in all Django projects at Zettabyte Inc.
Keywords: django

# drf_zettabyte

Simple yet powerful implementations that are used in all Django projects at Zettabyte Inc.


## Dependencies
1. Django
1. djangorestframework
1. djangorestframework_simplejwt
1. django-auditlog
1. django-islands
1. django-threadlocals
1. b2sdk
1. serpy
starsol-mongo-migrate 0.2.0
MongoDB migration tool
Requires Python: <4.0,>=3.11
Keywords: starsol

# MongoDB Migrations

## Overview
This project includes a CLI tool for managing MongoDB database migrations.

Migration scripts should utilize the `pymongo` library to interact with the database.

Migrations are performed in a transactional manner, 
meaning that if an error occurs during the execution of a migration, 
the migration will be rolled back and the database will be left in the state 
it was in before the migration was attempted.
To support this functionality MongoDB requires a replica set to be configured.


## Installation
```bash
pip install starsol-mongo-migrate
```

## Usage

### Python API
You can use the migration system programmatically in your Python scripts:

```python
from starsol_mongo_migrate import MigrationManager

# Create a migration manager
with MigrationManager('mongodb://localhost:27017/mydb', 'versions') as manager:
    # Initialize migration system
    manager.init()

    # Generate new migration
    revision = manager.generate('add_user_collection')

    # List migrations
    migrations = manager.list_migrations()
    for rev, name in migrations:
        print(f'{rev}: {name}')

    # Check current revision
    current = manager.current_revision()
    print(f'Current: {current}')

    # Upgrade to latest
    manager.upgrade()

    # Upgrade to specific revision
    manager.upgrade(target_revision='20250216000109')

    # Downgrade
    manager.downgrade(target_revision='20250216000109')

    # Use without transactions (for non-replica set)
    manager.upgrade(use_transactions=False)
```

### CLI Commands
This project also offers CLI commands to manage MongoDB migrations.

#### Initialize
Initialize the migration directory and the database version collection:
```bash
python3 -m starsol_mongo_migrate.cli --dir=versions init <your_mongo_uri>
```

#### Generate Migrations
Generate a new migration:
```bash
python3 -m starsol_mongo_migrate.cli --dir=versions generate migration_name
```

#### List Migrations
List all migrations:
```bash
python3 -m starsol_mongo_migrate.cli --dir=versions list
```

#### Upgrade Database
Upgrade the database to a specific revision:
```bash
python3 -m starsol_mongo_migrate.cli --dir=versions upgrade <your_mongo_uri> <target_revision>
```
Upgrade the database to the latest revision:
```bash
python3 -m starsol_mongo_migrate.cli --dir=versions upgrade <your_mongo_uri>
```
Upgrade without using transactions:
```bash
python3 -m starsol_mongo_migrate.cli --dir=versions upgrade --no-transaction <your_mongo_uri>
```

#### Downgrade Database
Downgrade the database to a specific revision:
```bash
python3 -m starsol_mongo_migrate.cli --dir=versions downgrade <your_mongo_uri> <target_revision>
```
Downgrade without using transactions:
```bash
python3 -m starsol_mongo_migrate.cli --dir=versions downgrade --no-transaction <your_mongo_uri> <target_revision>
```

#### Show Current Revision
Display the current database revision:
```bash
python3 -m starsol_mongo_migrate.cli --dir=versions current <your_mongo_uri>
```
symbolang 0.1.4
A simple 2D programming language.
Requires Python: >=3.12

# Symbolang
### a 2-dimensional, interpreted, programming language, inspired by [befunge](https://esolangs.org/wiki/Befunge)

## intro

The main concept of a Symbolang program is the 'pointer'. the pointer is the
imaginary cursor that executes each character one by one.

## Variable scope

This is a stack based language, (at least for now)

There aren't really any variables, but you are able to push and pop values to and from the stack.

## Syntax

| Symbol | Function |
|----------------|------------------------------------------|
| >              | Makes the pointer start moving left |
| <              | Makes the pointer start moving right |
| ^              | Makes the pointer start moving up |
| v              | Makes the pointer start moving down |
| ?              | Random pointer direction |
| _              | horizontal if statement; pops value from stack, if value is 0, set direction to right, if it's anything else set it to left. |
| \|              | horizontal if statement; pops value from stack, if value is 0, set direction to down, if it's anything else set it to up. |
| "              | toggles stringmode. if on, every character's ascii value will be pushed to the stack. |
|                | (single space) go to the next character |
| ,              | pops value from stack and prints ascii character corresponding to that value.     |
| .              | pops value from stack and prints it. |
| 1-9            | pushes corresponding value to stack. |
| /, *, +, or -  | pop two values from stack (a, then b), and then performs the operation on a and b and pushes result to stack.|
| ~              | gets a number or character from user, and pushes it to the stack. |

##### Table of functions

### Example Program
```
>" !dlroW ,olleH"v
^ ,,,,,,,,,,,,,, <
```


## Use
You've read about this amazing program, but how do you use it? 
first, install `pip` or similar.
then, you can run `pip install symbolang` to install it.


then, place your `.symb` file into the directory, and in your terminal, type
`symbolang [argument] [your-file-here]`.

### Arguments
if you run it with `--debug`, it will print debug info. docs on what it displays coming soon!

## Changelog
* v0.1.0
    * Made a debug mode. I feel like this is the first real version
* v0.1.2
    * HUGE quality of life upgrade :)
    * programs usually looked like this: `> 0 . 0 <`, but now they look like this: `>0.0<`
* v0.1.3
    * now this can be run as an actual CLI app.

## Roadmap
* At some point, it would be AMAZING if this had an interpreter in a compiled
language (instead of being interpreted to be interpreted).
* full befunge clone coming soon.
    * (and more after that)
* ~~up and down movement of cursor~~ <- completed
* interactive REPL would be awesome
* a [tulip](https://tulip.computer) port
mbusreader 0.1.0
M-Bus reader tool
Requires Python: >=3.9
Keywords: components, nicegui, ui

# mbusreader
Meterbus reader

[![pypi](https://img.shields.io/pypi/pyversions/mbusreader)](https://pypi.org/project/mbusreader/)
[![Github Actions Build](https://github.com/WolfgangFahl/mbusreader/actions/workflows/build.yml/badge.svg)](https://github.com/WolfgangFahl/mbusreader/actions/workflows/build.yml)
[![PyPI Status](https://img.shields.io/pypi/v/mbusreader.svg)](https://pypi.python.org/pypi/mbusreader/)
[![GitHub issues](https://img.shields.io/github/issues/WolfgangFahl/mbusreader.svg)](https://github.com/WolfgangFahl/mbusreader/issues)
[![GitHub closed issues](https://img.shields.io/github/issues-closed/WolfgangFahl/mbusreader.svg)](https://github.com/WolfgangFahl/mbusreader/issues/?q=is%3Aissue+is%3Aclosed)
[![API Docs](https://img.shields.io/badge/API-Documentation-blue)](https://WolfgangFahl.github.io/mbusreader/)
[![License](https://img.shields.io/github/license/WolfgangFahl/mbusreader.svg)](https://www.apache.org/licenses/LICENSE-2.0)

## Docs and Tutorials
[Wiki](https://wiki.bitplan.com/index.php/MBus_Reader)

# Introduction
## Demo
* [mbus viewer](https://mbus.bitplan.com)

## MBus Viewer
See also [Live M-Bus datagram decoder](https://dev-lab.github.io/tmbus/tmbus.htm)

The MBus-Viewer is a Python-based tool for decoding
M-Bus datagrams/telegrams from consumption meters and other
compatible devices. It leverages the [pyMeterBus](https://github.com/ganehag/pyMeterBus) library
to convert these datagrams into JSON and displays
the parsed results for analysis and debugging.

## MBus Reader
The MBus Reader is for reading M-Bus devices and optionally integration into
your favorite home automation by forwarding the JSON results e.g. via [MQTT](https://en.wikipedia.org/wiki/MQTT).

## Screenshot
![Screenshot](https://github.com/user-attachments/assets/ca0a41ae-6513-496c-b3ce-b3a892f66d3f)
pynite-plotly 0.4.1
A 3rd party visualization module for PyNiteFEA using plotly
Requires Python: >=3.10

# pynite_plotly: Plotly visualization for PyNiteFEA

## Installation

```
pip install pynite-plotly
```

## Basic Usage

`pynite-plotly` can be used as a drop-in replacement for PyNite's own PyVista rendering module.

So, simply replace:

```python
from PyNite.Rendering import Renderer
```

with this:

```python
from pynite_plotly import Renderer
```

And then visualize your model according to the API for the PyNite renderer:

```python
from PyNite import FEModel3D

model = FEModel3D()

### ... build your model here...

vis = Renderer(model)
vis.render_model()
```

## Additional Features
The `Renderer` class has a few additional attributes beyond the attributes in the PyNite `Renderer`. These are useful for modifying colors and line weights of the elements in the plot.

* `.colors` - A `dict` that has keys corresponding to the different elements in the plot
* `.line_widths` - A `dict` that has keys corresponding to the different linear elements in the plot

Change the values of the keys and run `.update` to see how they affect the plot!

## Current Limitations

2024-11-01: I have only implemented rendering frames and loads. I have not implemented plates/quads/area loads. It will take a special effort because plotly renderers meshes (the plates) as triangles but PyNite uses a quad mesh for FEA. 

So, to render everything like PyVista will require remeshing the quad mesh as triangles and having the ability to plot the lines of the quad mesh overtop of the triangulated quad mesh which can also have gradient shading according to the results being plotted.

Additionally, I have not implemented plotting of nodes and node labels yet. No real reason but I noticed that they were not implemented in the PyNite Renderer so I just kept chill on it...for now.


## Motivation

[PyNiteFEA](https://github.com/jwock82/pynite) is excellent and has been becoming more so. In v0.0.94 @JWock82 released PyVista visualization to complement the existing VTK visualization. This has been a great improvement in usability since PyVista can run within a Jupyter notebook as opposed to launching a separate operating system window for the visualization (VTK).

To get PyVista running in Jupyter, requires Trame and a load of other dependencies. These dependencies typically lag behind the latest Python version. Additionally, PyVista does not run everywhere on the web yet (like streamlit).

However, plotly has similar 3D plotting capability to PyVista, runs everywhere, and has a light dependency load.

So, using a helper library I created, [plotly_3d_primitives](https://github.com/structuralpython/plotly_3d_primitives), I then copied the original PyNite `Rendering` module and swapped out the PyVista method names with my new plotly function names. Did a little bit of massaging and...voila! A new rendering module for PyNite!