semvec/pypi-packages huggingface dataset:
rjm 1.4.0
Python module for creating and reading journal files for Autodesk Revit.

[![PyPi](https://img.shields.io/pypi/v/rjm.svg)](https://pypi.org/project/rjm)

# Revit Journal Maker

python libray for writing/reading journal files for Autodesk Revit

## Writing Journals

``` python
import rjm
journal_maker = rjm.JournalMaker(permissive=True)

# creating a new model (template_name is optional)
journal_maker.new_model(template_name='My Template')

# creating a new template model (template_name is optional)
journal_maker.new_template(template_name='My Template for Templates')

# creating other types
journal_maker.new_family(base_rft_file)
journal_maker.new_conceptual_mass(base_rft_file)
journal_maker.new_titleblock(base_rft_file)
journal_maker.new_annotation(base_rft_file)

# opening workshared model
journal_maker.open_workshared_model(model_full_path,
                                    central=False,
                                    detached=True,
                                    keep_worksets=True,
                                    audit=False,
                                    show_workset_config=1)

# opening non-workshared model
journal_maker.open_model(model_full_path)

# ignore missing links
journal_maker.ignore_missing_links()

# add custom entry to journal
journal_maker.add_custom_entry(journal_entry)

# execute an addon command
cmdata = {}     # dict of data to be passed to command in journal
journal_maker.execute_command(tab_name='Add-Ins',
                              panel_name='Panel Name',
                              command_module='Addon Application Namespace',
                              command_class='Command Classname',
                              command_data=cmdata)

# execute dynamo definition
journal_maker.execute_dynamo_definition(definition_path='C:/testdef.dyn',
                                      show_ui=True,
                                      shutdown=True)

# load a family
journal_maker.import_family(RFA_file_path)

# ask journal to export warnings using Revit UI
journal_maker.export_warnings(export_filepath)

# ask journal to purge unused warnings using Revit UI
journal_maker.purge_unused(pass_count=3)

# sync central model
journal_maker.sync_model(comment='comment string',
                         compact_central=True,
                         release_borrowed=True,
                         release_workset=True,
                         save_local=False)

# saving non-workshared model
journal_maker.save_model()

# closing model
journal_maker.close_model()

# finally
journal_maker.write_journal(journal_filepath)
```


## Reading Journals

Under Development

``` python
import rjm
journal_reader = rjm.JournalReader(active_journal_file)

# checking to see if the journal has crashed and stopped
journal_reader.is_stopped()
```
repsci 1.1.8
A tool for reproducible scientific computing
Requires Python: >=3.6

Installing.

    pip install repsci

Import the logging library.

    import repsci

Create an experiment. A unique directory will be created with the experiment
name, a timestamp, and the current git hash.

    exp_name = "hello_world"
    exp = repsci.Experiment(exp_name)

Get the logger and write a log message.

    log = exp.get_logger()
    log.debug("Hello, World!")

Create an output file in the unique output directory.

    filename = exp.get_filename('output.csv')
    with open(filename, "wb") as f:
        f.write("Hello, World\n")

The state of python's random number generator is stored in `random_state.bin`
in pickle format. This state can be used to reproduce the output of randomized
scripts.
        
The Experiment constructor also has some optional parameters:
* `note`: a string of notes to store in a `notes.txt` file in the output directory.
* `config`: a configparser object, which will exported to the output directory.
* `output_dir`: the subdirectory of the current directory to place experiment directories in.
* `suffix`: a string to append to the end of the trial's directory.

Create an experiment from a previous experiment's unique directory.

    exp_name = "hello_world"
    timestamp = "2020-09-09 152600"
    exp = repsci.Experiment(exp_name, reproduce=timestamp)
    
Get the config from the prevous experiment.

    config = exp.get_config()
lapymod 1.1
A simple wrapper for Labymod's API.
Requires Python: >=3.6

# Lapymod

This is a simple wrapper for the Labymod API.

## Installation

```pip install lapymod```

## Usage

```
import lapymod

#This creates a user that lets you query and update their data.
user = lapymod.User('34e57efa578346c7a9fc890296aaba1f') #(The uuid of LabyStudio -- an admin for Labymod)

#Returns all emotes for the user into a list.
emotes = user.getEmotes()

#Returns all cosmetics for the user into a list.
cosmetics = user.getCosmetics()

#Returns all stickers for the user into a list.
stickers = user.getStickers()

#Returns all roles for the user into a list.
roles = user.getRoles()

#Returns all of the above functions in one nice easy to use dictionary.
all_data = user.getAllData()

#You can change the user while you go.
user.setUser('32645503-0d51-4fc6-8e4a-28b03714db5e') #(The uuid of LabyMarco -- another admin for Labymod)

#When you either want new data for the user or want to change the data with a new supplied user, update it!
user.update()

#Returns True/False if the module is able to connect to the Labymod API.
api_status = lapymod.getStatus()

#Returns the current daily shop emotes in a list.
shop_emotes = lapymod.getShopEmotes()
```
flightpy 0.0.0.post4
a modern python web framework with super powers
Keywords: python,framework,web framework

# FlightPY | A Modern Python Web Framework

FlightPY is heavily inspired by the Express framework.
Python is one of my favorite languages, and it deserves to have some updated tooling for web developers.

## Why Another Framework

Isn't Flask or Django enough? Probably. But the thing I've found with using those frameworks is that they seem to be on either end of the web development spectrum as far as Python is concerned. 

FlightPY will sit somewhere in between Flask and Django. Where Flask is basically BYOE (bring your own everything) and Django is all Batteries included (and you need to know how everything works the Django way), FlightPY will attempt to provide the modularity neccessary for lightweight Python apps (via awesome middlewares), while still providing enough out of the box to get stuff done quickly.

## A Modern Approach

A lot of the python frameworks were developed at a time when the web was a very different place. Some of the best features of Python may not have even existed yet. Also, some frameworks were designed and are still maintaining Python2 legacy code that has reached EOL. FlightPY is designed for Python3+ and never plans to support Python2. This allows clear focus to be on the features of the framework and not maintaining legacy code.

## A Modular Middleware Approach

There are some very opinionated frameworks out there, like Django. For every opinion it has, it increases the steepness of the learning curve for that framework, along with the amount of time to actually build anything.

On the flip side of that, frameworks like Flask are very unopinionated, but they leave it up to you to decide if or what you want to use for almost every part of your project. While its minimialisitic (*yay!*), I've often found myself in the same situation of try to make a decision that I wish the framework would've already made for me.

There is a delicate balance to which opinions are important enough to have to provide some level of common functionality, while also not increasing the learning curve of the system as a whole.

That is where the FlightPY middlewares come into play. The core framework is very small. Its actually smaller than Flask. The rest of the functionality comes from middlewares. If you don't import them, they won't bloat your project.