semvec/pypi-packages huggingface dataset:
rescape-graphene 0.4.19
Graphene helpers for rescape projects

# rescape_graphene
Graphene helpers for rescape projects

## Installation

Create a virtual environment using
```bash
mkdir ~/.virtualenvs
python3 -m venv ~/.virtualenvs/rescape-graphene
Activate it
source ~/.virtualenvs/rescape-graphene/bin/activate
```

#### Install requirements
If you don't have pur installed:
pip install pur

This updates requirements.txt to their latest version

Install requirements with latest versions
```bash
pur -r requirements.txt && $VIRTUAL_ENV/bin/pip3 install --no-cache-dir  --upgrade -r requirements.txt
```

Add the following to the bottom $VIRTUAL_ENV/bin/activate to setup the PYTHONPATH.
Replace the path with your code directory

```bash
export RESCAPE_GRAPHENE_BASE_DIR=/Users/andy/code/rescape-graphene
export RESCAPE_GRAPHENE_PROJECT_DIR=$RESCAPE_GRAPHENE_BASE_DIR/urbinsight
export PYTHONPATH=.:$RESCAPE_GRAPHENE_BASE_DIR:$RESCAPE_GRAPHENE_PROJECT_DIR
```

## Build

Update the version in setup.py
Run to generate build:
Update the version with bumpversion, which can't seem to look it up itself but udpates setup.py

```bash
git commit . -m "Version update" && git push
bumpversion --current-version {look in setup.py} patch setup.py
python3 setup.py clean sdist bdist_wheel
```

To distribute to testpypi site:
Upload package:

```bash
twine upload dist/*
```

All at once
``` bash
git commit . -m "Version update" && git push && bumpversion --current-version {look in setup.py} patch setup.py && python3 setup.py clean sdist bdist_wheel && twine upload dist/*
# without commit
bumpversion --current-version {look in setup.py} patch setup.py && python3 setup.py clean sdist bdist_wheel && twine upload dist/*
```

For setup of testpypi see ~/.pypirc or create one according to the testpypi docs:
e.g.:
[distutils]
index-servers=
    pypi
    testpypi

[testpypi]
repository: https://test.pypi.org/legacy/
username: your username for pypi.org

## Running tests
Create a postgres database rescape_graphene
# Login to psql:
CREATE DATABASE rescape_graphene;
CREATE USER test_user WITH PASSWORD 'test';
GRANT ALL PRIVILEGES ON DATABASE rescape_graphene to test_user;
# Give Superuser permission to create test databases
ALTER ROLE test_user SUPERUSER;

# Run the migrations
# Create a Django user test with pw testpass
 ./manage.py createsuperuser
 # or
 echo "from django.contrib.auth import get_user_model; User = get_user_model(); User.objects.create_superuser('test', 'test@nowhere.man', 'testpass')" | ./manage.py shell
xycepymi 7.4.0
Xyce
Requires Python: >=3.6

Future location of Python enabled Xyce.

In the meantime, check out Xyce-PyMi at:
https://github.com/xyce/xyce

with instruction details at:
https://cfwebprod.sandia.gov/cfdocs/CompResearch/docs/Xyce-PyMi-Guide.pdf



About Xyce:

Xyce (rhymes with "spice") is an open source, SPICE-compatible, high-performance analog circuit simulator, capable of solving extremely large circuit problems by supporting large-scale parallel computing platforms. It also supports serial execution on all common desktop platforms, and small-scale parallel runs on Unix-like systems. In addition to analog electronic simulation, Xyce has also been used to investigate more general network systems, such as neural networks and power grids. In providing an Open Source version of Xyce to the external community, Sandia hopes to contribute a robust and modern electronic simulator to users and researchers in the field.

While designed to be SPICE-compatible, Xyce is not a derivative of SPICE. Xyce was designed from scratch to be a parallel simulation code, written in C++ and using a message-passing implementation (MPI). Xyce also leverages Sandia's open-source solver library, Trilinos, which includes a number of circuit-specific solvers, such as the KLU direct solver. With its modular and flexible design, Xyce applies abstract interfaces to enable easy development of different analysis types, solvers and models.

Xyce is compatible with SPICE-based codes, in that it supports a canonical set of SPICE compact models and standard SPICE analysis methods, such as steady-state (.DC), transient (.TRAN), small-signal frequency domain (.AC), and noise (.NOISE). However, Xyce goes beyond most SPICE-based codes in a number of ways, including support for a large number of non-traditional models, such as neuron and reaction network models. Xyce also supports Harmonic Balance analysis (.HB), random sampling analysis, sensitivity calculations, and post processing of the simulation metrics (.FOUR and .MEASURE).
xyce 7.4.0
Xyce
Requires Python: >=3.6

Future location of Python enabled Xyce.

In the meantime, check out Xyce-PyMi at:
https://github.com/xyce/xyce

with instruction details at:
https://cfwebprod.sandia.gov/cfdocs/CompResearch/docs/Xyce-PyMi-Guide.pdf



About Xyce:

Xyce (rhymes with "spice") is an open source, SPICE-compatible, high-performance analog circuit simulator, capable of solving extremely large circuit problems by supporting large-scale parallel computing platforms. It also supports serial execution on all common desktop platforms, and small-scale parallel runs on Unix-like systems. In addition to analog electronic simulation, Xyce has also been used to investigate more general network systems, such as neural networks and power grids. In providing an Open Source version of Xyce to the external community, Sandia hopes to contribute a robust and modern electronic simulator to users and researchers in the field.

While designed to be SPICE-compatible, Xyce is not a derivative of SPICE. Xyce was designed from scratch to be a parallel simulation code, written in C++ and using a message-passing implementation (MPI). Xyce also leverages Sandia's open-source solver library, Trilinos, which includes a number of circuit-specific solvers, such as the KLU direct solver. With its modular and flexible design, Xyce applies abstract interfaces to enable easy development of different analysis types, solvers and models.

Xyce is compatible with SPICE-based codes, in that it supports a canonical set of SPICE compact models and standard SPICE analysis methods, such as steady-state (.DC), transient (.TRAN), small-signal frequency domain (.AC), and noise (.NOISE). However, Xyce goes beyond most SPICE-based codes in a number of ways, including support for a large number of non-traditional models, such as neuron and reaction network models. Xyce also supports Harmonic Balance analysis (.HB), random sampling analysis, sensitivity calculations, and post processing of the simulation metrics (.FOUR and .MEASURE).
python-eloqua-wrapper 0.0.9
A wrapper for Eloqua's HTTP REST API

# python-eloqua-wrapper

This outlines the current behavior and use cases of the API via an example.

Functionality includes creating, updating, or deleting Custom Data Object records in Eloqua, and 
creating, retrieving, or deleting Contacts in Eloqua.

# Example Outline

Let's say we have a CDO with ID# 12345, and a record with these field values:

Record ID#369789
- business_email: bob@bobbyworld.com 
- first_last_name: bob_wilbert
- zip_code: 32123
- job_title: Nannygoat Herder

We would like to update him in our CDO with the following:
- zip_code: 22667
- job_title: Alligator Wrangler

How do we upload changes via our lovely api wrapper?

## Step 1: What you need to upload data to Eloqua

To push a given record with the basic CdoRecord class, you will need:

- the CDO ID
- the CDO record ID
- A dictionary of the fieldName:value pairs you want to upload/update
- A dictionary of the fieldName:fieldID pairs to map your fieldsNames
    
## Step 2: bare bones initialization

```
from python_eloqua_wrapper.cdo_record import CdoRecord
from python_eloqua_wrapper.eloqua_session import EloquaSession
from os import environ

session = EloquaSession(company=environ["ELOQUA_COMPANY"], 
                        username=environ["ELOQUA_USER"], 
                        password=environ["ELOQUA_PASSWORD"])

cdo_record = CdoRecord(session=session)
```

That's it, you now have a local object!

## Step 3: Updating your record

There is a method called `update_cdo_record`, which can be used as follows:

```
cdo_record.update_cdo_record(
    cdo_id=12345, 
    record_id=369789, 
    cdo_field_to_field_id_map={
        'zip_code': 11221,
        'job_title': 11232}, 
    record_fields_and_values_dict={
        'zip_code': '22667',
        'job_title': 'Alligator Wrangler'})
```
Simply execute this and you will receive the response object if it was successful, else it will raise an exception.

To be more explicit about update behavior:

- If a previous value for that field/column already existed: it gets overwritten.
- If you don't provide a field/column name, it won't alter that column.
testOrganizer 0.0.7
Organize tests and show results
Keywords: test,before,after,automation,result,console,output

How to use it:

```
from testOrganizer.TestDecorator import test, beforeEachTest, afterEachTest, print_result

@beforeEachTest()
def be():
print("before each test")

@afterEachTest()
def ae():
print("after each test")


@test("First test", should_execute=False, info="Bug found")
def test1():
print("test")

@test("Second test")
def test2():
print("test")

print_result()
print_html("LoginFeature", r"C:\Users\us\Desktop\htmlLogs\testOrganizer.html")
```

Important notes:
- beforeEachTest and afterEachTest must be defined first
- print_result() should be called so that result is printed to console (at the end of file)
- print_html() should be called to print result to html (at the end of file)
- for sharing variables over functions, python rules are applied
- code outside of given functions will also be executed as in standard python script



For sharing variables over functions example:

```
browser = webdriver.Chrome()

@test("First test")
def test1():
    global browser
    browser.get(url)
```