<div align="center">

# **Bittensor** <!-- omit in toc -->
[![Discord Chat](https://img.shields.io/discord/308323056592486420.svg)](https://discord.gg/bittensor)
[![PyPI version](https://badge.fury.io/py/bittensor.svg)](https://badge.fury.io/py/bittensor)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

---

### Internet-scale Neural Networks <!-- omit in toc -->

[Discord](https://discord.gg/qasY3HA9F9) • [Network](https://taostats.io/) • [Research](https://bittensor.com/whitepaper)

</div>

Bittensor is a mining network, similar to Bitcoin, that includes built-in incentives designed to encourage computers to provide access to machine learning models in an efficient and censorship-resistant manner. These models can be queried by users seeking outputs from the network, for instance; generating text, audio, and images, or for extracting numerical representations of these input types. Under the hood, Bittensor’s *economic market*, is facilitated by a blockchain token mechanism, through which producers (***miners***) and the verification of the work done by those miners (***validators***) are rewarded. Miners host, train or otherwise procure machine learning systems into the network as a means of fulfilling the verification problems defined by the validators, like the ability to generate responses from prompts i.e. “What is the capital of Texas?.

The token based mechanism under which the miners are incentivized ensures that they are constantly driven to make their knowledge output more useful, in terms of speed, intelligence and diversity. The value generated by the network is distributed directly to the individuals producing that value, without intermediaries. Anyone can participate in this endeavour, extract value from the network, and govern Bittensor. The network is open to all participants, and no individual or group has full control over what is learned, who can profit from it, or who can access it.

To learn more about Bittensor, please read our [paper](https://bittensor.com/whitepaper).

# Install
There are three ways to install Bittensor

1. Through the installer:
```bash
$ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/opentensor/bittensor/master/scripts/install.sh)"
```
2. With pip:
```bash
$ pip3 install bittensor
```
3. From source:
```bash
$ git clone https://github.com/opentensor/bittensor.git
$ python3 -m pip install -e bittensor/
```
4. Using Conda (recommended for **Apple M1**):
```bash
$ conda env create -f ~/.bittensor/bittensor/scripts/environments/apple_m1_environment.yml
$ conda activate bittensor
```

To test your installation, type:
```bash
$ btcli --help
```
or using python
```python
import bittensor
```

#### CUDA
If you anticipate using PoW registration for subnets or the faucet (only available on staging), please install `cubit` as well for your version of python. You can find the Opentensor cubit implementation and instructions [here](https://github.com/opentensor/cubit).

For example with python 3.10:
```bash
pip install https://github.com/opentensor/cubit/releases/download/v1.1.2/cubit-1.1.2-cp310-cp310-linux_x86_64.whl
```

# Wallets

Wallets are the core ownership and identity technology around which all functions on Bittensor are carried out. Bittensor wallets consists of a coldkey and hotkey where the coldkey may contain many hotkeys, while each hotkey can only belong to a single coldkey. Coldkeys store funds securely, and operate functions such as transfers and staking, while hotkeys are used for all online operations such as signing queries, running miners and validating.

Wallets can be created in two ways.
1. Using the python-api
```python
import bittensor
wallet = bittensor.wallet()
wallet.create_new_coldkey()
wallet.create_new_hotkey()
print (wallet)
"Wallet (default, default, ~/.bittensor/wallets/)"
```
2. Or using btcli
> Use the subcommand `wallet` or it's alias `w`:
```bash
$ btcli wallet new_coldkey
    Enter wallet name (default):

    IMPORTANT: Store this mnemonic in a secure (preferably offline place), as anyone who has possession of this mnemonic can use it to regenerate the key and access your tokens.
    The mnemonic to the new coldkey is:
    **** *** **** **** ***** **** *** **** **** **** ***** *****
    You can use the mnemonic to recreate the key in case it gets lost. The command to use to regenerate the key using this mnemonic is:
    btcli w regen_coldkey --mnemonic post maid erode shy captain verify scan shoulder brisk mountain pelican elbow

$ btcli wallet new_hotkey
    Enter wallet name (default): d1
    Enter hotkey name (default):

    IMPORTANT: Store this mnemonic in a secure (preferably offline place), as anyone who has possession of this mnemonic can use it to regenerate the key and access your tokens.
    The mnemonic to the new hotkey is:
    **** *** **** **** ***** **** *** **** **** **** ***** *****
    You can use the mnemonic to recreate the key in case it gets lost. The command to use to regenerate the key using this mnemonic is:
    btcli w regen_hotkey --mnemonic total steak hour bird hedgehog trim timber can friend dry worry text
```
In both cases you should be able to view your keys by navigating to ~/.bittensor/wallets or viewed by running ```btcli wallet list```
```bash
$ tree ~/.bittensor/
    .bittensor/                 # Bittensor, root directory.
        wallets/                # The folder containing all bittensor wallets.
            default/            # The name of your wallet, "default"
                coldkey         # You encrypted coldkey.
                coldkeypub.txt  # Your coldkey public address
                hotkeys/        # The folder containing all of your hotkeys.
                    default     # You unencrypted hotkey information.
```
Your default wallet ```Wallet (default, default, ~/.bittensor/wallets/)``` is always used unless you specify otherwise. Be sure to store your mnemonics safely. If you lose your password to your wallet, or the access to the machine where the wallet is stored, you can always regenerate the coldkey using the mnemonic you saved from above.
```bash
$ btcli wallet regen_coldkey --mnemonic **** *** **** **** ***** **** *** **** **** **** ***** *****
```

## Using the cli
The Bittensor command line interface (`btcli`) is the primary command line tool for interacting with the Bittensor network. It can be used to deploy nodes, manage wallets, stake/unstake, nominate, transfer tokens, and more.

### Basic Usage

To get the list of all the available commands and their descriptions, you can use:

```bash
btcli --help

usage: btcli <command> <command args>

bittensor cli v{bittensor.__version__}

commands:
  subnets (s, subnet) - Commands for managing and viewing subnetworks.
  root (r, roots) - Commands for managing and viewing the root network.
  wallet (w, wallets) - Commands for managing and viewing wallets.
  stake (st, stakes) - Commands for staking and removing stake from hotkey accounts.
  sudo (su, sudos) - Commands for subnet management.
  legacy (l) - Miscellaneous commands.
```

### Example Commands

#### Viewing Senate Proposals
```bash
btcli root proposals
```

#### Viewing Senate Members
```bash
btcli root list_delegates
```

#### Viewing Proposal Votes
```bash
btcli root senate_vote --proposal=[PROPOSAL_HASH]
```

#### Registering for Senate
```bash
btcli root register
```

#### Leaving Senate
```bash
btcli root undelegate
```

#### Voting in Senate
```bash
btcli root senate_vote --proposal=[PROPOSAL_HASH]
```

#### Miscellaneous Commands
```bash
btcli legacy update
btcli legacy faucet
```

#### Managing Subnets
```bash
btcli subnets list
btcli subnets create
```

#### Managing Wallets
```bash
btcli wallet list
btcli wallet transfer
```

### Note

Please replace the subcommands and arguments as necessary to suit your needs, and always refer to `btcli --help` or `btcli <command> --help` for the most up-to-date and accurate information.

For example:
```bash
btcli subnets --help

usage: btcli <command> <command args> subnets [-h] {list,metagraph,lock_cost,create,register,pow_register,hyperparameters} ...

positional arguments:
  {list,metagraph,lock_cost,create,register,pow_register,hyperparameters}
                        Commands for managing and viewing subnetworks.
    list                List all subnets on the network.
    metagraph           View a subnet metagraph information.
    lock_cost           Return the lock cost to register a subnet.
    create              Create a new bittensor subnetwork on this chain.
    register            Register a wallet to a network.
    pow_register        Register a wallet to a network using PoW.
    hyperparameters     View subnet hyperparameters.

options:
  -h, --help            show this help message and exit
```

### Post-Installation Steps

To enable autocompletion for Bittensor CLI, run the following commands:

```bash
btcli --print-completion bash >> ~/.bashrc  # For Bash
btcli --print-completion zsh >> ~/.zshrc    # For Zsh
source ~/.bashrc  # Reload Bash configuration to take effect
```

# The Bittensor Package
The bittensor package contains data structures for interacting with the bittensor ecosystem, writing miners, validators and querying the network. Additionally, it provides many utilities for efficient serialization of Tensors over the wire, performing data analysis of the network, and other useful utilities.

In the 7.0.0 release, we have removed `torch` by default. However, you can still use `torch` by setting the environment variable
`USE_TORCH=1` and making sure that you have installed the `torch` library.
You can install `torch` by running `pip install bittensor[torch]` (if installing via PyPI), or by running `pip install -e ".[torch]"` (if installing from source).
We will not be adding any new functionality based on torch.

Wallet: Interface over locally stored bittensor hot + coldkey styled wallets.
```python
import bittensor
# Bittensor's wallet maintenance class.
wallet = bittensor.wallet()
# Access the hotkey
wallet.hotkey
# Access the coldkey
wallet.coldkey ( requires decryption )
# Sign data with the keypair.
wallet.coldkey.sign( data )

```

Subtensor: Interfaces with bittensor's blockchain and can perform operations like extracting state information or sending transactions.
```python
import bittensor
# Bittensor's chain interface.
subtensor = bittensor.subtensor()
# Get the chain block
subtensor.get_current_block()
# Transfer Tao to a destination address.
subtensor.transfer( wallet = wallet, dest = "xxxxxxx..xxxxx", amount = 10.0)
# Register a wallet onto a subnetwork
subtensor.register( wallet = wallet, netuid = 1 )
```

Metagraph: Encapsulates the chain state of a particular subnetwork at a specific block.
```python
import bittensor
# Bittensor's chain state object.
metagraph = bittensor.metagraph( netuid = 1 )
# Resync the graph with the most recent chain state
metagraph.sync()
# Get the list of stake values
print ( metagraph.S )
# Get endpoint information for the entire subnetwork
print ( metagraph.axons )
# Get the hotkey information for the miner in the 10th slot
print ( metagraph.hotkeys[ 10 ] )
# Sync the metagraph at another block
metagraph.sync( block = 100000 )
# Save the metagraph
metagraph.save()
# Load the same
metagraph.load()
```

Synapse: Responsible for defining the protocol definition between axon servers and dendrite clients
```python
class Topk( bittensor.Synapse ):
    topk: int = 2  # Number of "top" elements to select
    input: bittensor.Tensor = pydantic.Field(..., frozen=True)  # Ensure that input cannot be set on the server side.
    v: bittensor.Tensor = None
    i: bittensor.Tensor = None

def topk( synapse: Topk ) -> Topk:
    v, i = torch.topk( synapse.input.deserialize(), k = synapse.topk )
    synapse.v = bittensor.Tensor.serialize( v )
    synapse.i = bittensor.Tensor.serialize( i )
    return synapse

# Attach the forward function to the axon and start.
axon = bittensor.axon().attach( topk ).start()
```

Axon: Serves Synapse protocols with custom blacklist, priority and verify functions.

```python
import bittensor

class MySynapse( bittensor.Synapse ):
    input: int = 1
    output: int = None

# Define a custom request forwarding function
def forward( synapse: MySynapse ) -> MySynapse:
    # Apply custom logic to synapse and return it
    synapse.output = 2
    return synapse

# Define a custom request verification function
def verify_my_synapse( synapse: MySynapse ):
    # Apply custom verification logic to synapse
    # Optionally raise Exception

# Define a custom request blacklist function
def blacklist_my_synapse( synapse: MySynapse ) -> bool:
    # Apply custom blacklist
    # return False ( if non blacklisted ) or True ( if blacklisted )

# Define a custom request priority function
def prioritize_my_synape( synapse: MySynapse ) -> float:
    # Apply custom priority
    return 1.0

# Initialize Axon object with a custom configuration
my_axon = bittensor.axon(config=my_config, wallet=my_wallet, port=9090, ip="192.0.2.0", external_ip="203.0.113.0", external_port=7070)

# Attach the endpoint with the specified verification and forwarding functions
my_axon.attach(
    forward_fn = forward_my_synapse,
    verify_fn=verify_my_synapse,
    blacklist_fn = blacklist_my_synapse,
    priority_fn = prioritize_my_synape
).start()
```

Dendrite: Represents the abstracted implementation of a network client module
designed to send requests to those endpoints to receive inputs.

Example:
```python
dendrite_obj = dendrite( wallet = bittensor.wallet() )
# pings the axon endpoint
await d( <axon> )
# ping multiple axon endpoints
await d( [<axons>] )
# Send custom synapse request to axon.
await d( bittensor.axon(), bittensor.Synapse() )
# Query all metagraph objects.
await d( meta.axons, bittensor.Synapse() )
```

## Setting weights on root network
Use the `root` subcommand to access setting weights on the network across subnets.

```bash
btcli root weights --wallet.name <coldname> --wallet.hotkey <hotname>
Enter netuids (e.g. 0, 1, 2 ...):
# Here enter your selected netuids to set weights on
1, 2

>Enter weights (e.g. 0.09, 0.09, 0.09 ...):
# These do not need to sum to 1, we do normalization on the backend.
# Values must be > 0
0.5, 10

Normalized weights:
        tensor([ 0.5000, 10.0000]) -> tensor([0.0476, 0.9524])

Do you want to set the following root weights?:
  weights: tensor([0.0476, 0.9524])
  uids: tensor([1, 2])? [y/n]:
y

⠏ 📡 Setting root weights on test ...
```

## Bittensor Subnets API

This guide provides instructions on how to extend the Bittensor Subnets API, a powerful interface for interacting with the Bittensor network across subnets. The Bittensor Subnets API facilitates querying across any subnet that has exposed API endpoints to unlock utility of the Bittensor decentralized network.

The Bittensor Subnets API consists of abstract classes and a registry system to dynamically handle API interactions. It allows developers to implement custom logic for storing and retrieving data, while also providing a straightforward way for end users to interact with these functionalities.

### Core Components

- **APIRegistry**: A central registry that manages API handlers. It allows for dynamic retrieval of handlers based on keys.
- **SubnetsAPI (Abstract Base Class)**: Defines the structure for API implementations, including methods for querying the network and processing responses.
- **StoreUserAPI & RetrieveUserAPI**: Concrete implementations of the `SubnetsAPI` for storing and retrieving user data.

### Implementing Custom Subnet APIs

To implement your own subclasses of `bittensor.SubnetsAPI` to integrate an API into your subnet.

1. **Inherit from `SubnetsAPI`**: Your class should inherit from the `SubnetsAPI` abstract base class.

2. **Implement Required Methods**: Implement the `prepare_synapse` and `process_responses` abstract methods with your custom logic.

That's it! For example:

```python
import bittensor

class CustomSubnetAPI(bittensor.SubnetsAPI):
    def __init__(self, wallet: "bittensor.wallet"):
        super().__init__(wallet)
        # Custom initialization here

    def prepare_synapse(self, *args, **kwargs):
        # Custom synapse preparation logic
        pass

    def process_responses(self, responses):
        # Custom response processing logic
        pass
```

## Release
The release manager should follow the instructions of the [RELEASE_GUIDELINES.md](./RELEASE_GUIDELINES.md) document.

## Contributions
Please review the [contributing guide](./contrib/CONTRIBUTING.md) for more information before making a pull request.

## License
The MIT License (MIT)
Copyright © 2021 Yuma Rao

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

## Acknowledgments
**learning-at-home/hivemind**


.. image:: https://scrapy.org/img/scrapylogo.png
   :target: https://scrapy.org/

======
Scrapy
======

.. image:: https://img.shields.io/pypi/v/Scrapy.svg
   :target: https://pypi.python.org/pypi/Scrapy
   :alt: PyPI Version

.. image:: https://img.shields.io/pypi/pyversions/Scrapy.svg
   :target: https://pypi.python.org/pypi/Scrapy
   :alt: Supported Python Versions

.. image:: https://github.com/scrapy/scrapy/workflows/Ubuntu/badge.svg
   :target: https://github.com/scrapy/scrapy/actions?query=workflow%3AUbuntu
   :alt: Ubuntu

.. .. image:: https://github.com/scrapy/scrapy/workflows/macOS/badge.svg
   .. :target: https://github.com/scrapy/scrapy/actions?query=workflow%3AmacOS
   .. :alt: macOS

.. image:: https://github.com/scrapy/scrapy/workflows/Windows/badge.svg
   :target: https://github.com/scrapy/scrapy/actions?query=workflow%3AWindows
   :alt: Windows

.. image:: https://img.shields.io/badge/wheel-yes-brightgreen.svg
   :target: https://pypi.python.org/pypi/Scrapy
   :alt: Wheel Status

.. image:: https://img.shields.io/codecov/c/github/scrapy/scrapy/master.svg
   :target: https://codecov.io/github/scrapy/scrapy?branch=master
   :alt: Coverage report

.. image:: https://anaconda.org/conda-forge/scrapy/badges/version.svg
   :target: https://anaconda.org/conda-forge/scrapy
   :alt: Conda Version

Overview
========

Scrapy is a BSD-licensed fast high-level web crawling and web scraping framework, used to
crawl websites and extract structured data from their pages. It can be used for
a wide range of purposes, from data mining to monitoring and automated testing.

Scrapy is maintained by Zyte_ (formerly Scrapinghub) and `many other
contributors`_.

.. _many other contributors: https://github.com/scrapy/scrapy/graphs/contributors
.. _Zyte: https://www.zyte.com/

Check the Scrapy homepage at https://scrapy.org for more information,
including a list of features.

Requirements
============

* Python 3.8+
* Works on Linux, Windows, macOS, BSD

Install
=======

The quick way:

.. code:: bash

    pip install scrapy

See the install section in the documentation at
https://docs.scrapy.org/en/latest/intro/install.html for more details.

Documentation
=============

Documentation is available online at https://docs.scrapy.org/ and in the ``docs``
directory.

Releases
========

You can check https://docs.scrapy.org/en/latest/news.html for the release notes.

Community (blog, twitter, mail list, IRC)
=========================================

See https://scrapy.org/community/ for details.

Contributing
============

See https://docs.scrapy.org/en/master/contributing.html for details.

Code of Conduct
---------------

Please note that this project is released with a Contributor `Code of Conduct <https://github.com/scrapy/scrapy/blob/master/CODE_OF_CONDUCT.md>`_.

By participating in this project you agree to abide by its terms.
Please report unacceptable behavior to opensource@zyte.com.

Companies using Scrapy
======================

See https://scrapy.org/companies/ for a list.

Commercial Support
==================

See https://scrapy.org/support/ for details.


Detectron2 is Facebook AI Research's next generation library
that provides state-of-the-art detection and segmentation algorithms.
It is the successor of
[Detectron](https://github.com/facebookresearch/Detectron/)
and [maskrcnn-benchmark](https://github.com/facebookresearch/maskrcnn-benchmark/).
It supports a number of computer vision research projects and production applications in Facebook.

## Learn More about Detectron2

Explain Like I’m 5: Detectron2            |  Using Machine Learning with Detectron2
:-------------------------:|:-------------------------:
[![Explain Like I’m 5: Detectron2](https://img.youtube.com/vi/1oq1Ye7dFqc/0.jpg)](https://www.youtube.com/watch?v=1oq1Ye7dFqc)  |  [![Using Machine Learning with Detectron2](https://img.youtube.com/vi/eUSgtfK4ivk/0.jpg)](https://www.youtube.com/watch?v=eUSgtfK4ivk)

## What's New
* Includes new capabilities such as panoptic segmentation, Densepose, Cascade R-CNN, rotated bounding boxes, PointRend,
  DeepLab, ViTDet, MViTv2 etc.
* Used as a library to support building [research projects](projects/) on top of it.
* Models can be exported to TorchScript format or Caffe2 format for deployment.
* It [trains much faster](https://detectron2.readthedocs.io/notes/benchmarks.html).

See our [blog post](https://ai.facebook.com/blog/-detectron2-a-pytorch-based-modular-object-detection-library-/)
to see more demos and learn about detectron2.

## Installation

See [installation instructions](https://detectron2.readthedocs.io/tutorials/install.html).

## Getting Started

See [Getting Started with Detectron2](https://detectron2.readthedocs.io/tutorials/getting_started.html),
and the [Colab Notebook](https://colab.research.google.com/drive/16jcaJoc6bCFAQ96jDe2HwtXj7BMD_-m5)
to learn about basic usage.

Learn more at our [documentation](https://detectron2.readthedocs.org).
And see [projects/](projects/) for some projects that are built on top of detectron2.

## Model Zoo and Baselines

We provide a large set of baseline results and trained models available for download in the [Detectron2 Model Zoo](MODEL_ZOO.md).

## License

Detectron2 is released under the [Apache 2.0 license](LICENSE).

## Citing Detectron2

If you use Detectron2 in your research or wish to refer to the baseline results published in the [Model Zoo](MODEL_ZOO.md), please use the following BibTeX entry.

```BibTeX
@misc{wu2019detectron2,
  author =       {Yuxin Wu and Alexander Kirillov and Francisco Massa and
                  Wan-Yen Lo and Ross Girshick},
  title =        {Detectron2},
  howpublished = {\url{https://github.com/facebookresearch/detectron2}},
  year =         {2019}
}
```


-----------------------------------------

[![Build Status](https://github.com/pyro-ppl/pyro/workflows/CI/badge.svg)](https://github.com/pyro-ppl/pyro/actions)
[![Coverage Status](https://coveralls.io/repos/github/pyro-ppl/pyro/badge.svg?branch=dev)](https://coveralls.io/github/pyro-ppl/pyro?branch=dev)
[![Latest Version](https://badge.fury.io/py/pyro-ppl.svg)](https://pypi.python.org/pypi/pyro-ppl)
[![Documentation Status](https://readthedocs.org/projects/pyro-ppl/badge/?version=dev)](http://pyro-ppl.readthedocs.io/en/stable/?badge=dev)
[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/3056/badge)](https://bestpractices.coreinfrastructure.org/projects/3056)

[Getting Started](http://pyro.ai/examples) |
[Documentation](http://docs.pyro.ai/) |
[Community](http://forum.pyro.ai/) |
[Contributing](https://github.com/pyro-ppl/pyro/blob/master/CONTRIBUTING.md)

Pyro is a flexible, scalable deep probabilistic programming library built on PyTorch.  Notably, it was designed with these principles in mind:

- **Universal**: Pyro is a universal PPL - it can represent any computable probability distribution.
- **Scalable**: Pyro scales to large data sets with little overhead compared to hand-written code.
- **Minimal**: Pyro is agile and maintainable. It is implemented with a small core of powerful, composable abstractions.
- **Flexible**: Pyro aims for automation when you want it, control when you need it. This is accomplished through high-level abstractions to express generative and inference models, while allowing experts easy-access to customize inference.

Pyro was originally developed at Uber AI and is now actively maintained by community contributors, including a dedicated team at the [Broad Institute](https://www.broadinstitute.org/).
In 2019, Pyro [became](https://www.linuxfoundation.org/press-release/2019/02/pyro-probabilistic-programming-language-becomes-newest-lf-deep-learning-project/) a project of the Linux Foundation, a neutral space for collaboration on open source software, open standards, open data, and open hardware.

For more information about the high level motivation for Pyro, check out our [launch blog post](http://eng.uber.com/pyro).
For additional blog posts, check out work on [experimental design](https://eng.uber.com/oed-pyro-release/) and
[time-to-event modeling](https://eng.uber.com/modeling-censored-time-to-event-data-using-pyro/) in Pyro.

## Installing

### Installing a stable Pyro release

**Install using pip:**
```sh
pip install pyro-ppl
```

**Install from source:**
```sh
git clone git@github.com:pyro-ppl/pyro.git
cd pyro
git checkout master  # master is pinned to the latest release
pip install .
```

**Install with extra packages:**

To install the dependencies required to run the probabilistic models included in the `examples`/`tutorials` directories, please use the following command:
```sh
pip install pyro-ppl[extras]
```
Make sure that the models come from the same release version of the [Pyro source code](https://github.com/pyro-ppl/pyro/releases) as you have installed.

### Installing Pyro dev branch

For recent features you can install Pyro from source.

**Install Pyro using pip:**

```sh
pip install git+https://github.com/pyro-ppl/pyro.git
```
or, with the `extras` dependency to run the probabilistic models included in the `examples`/`tutorials` directories:
```sh
pip install git+https://github.com/pyro-ppl/pyro.git#egg=project[extras]
```

**Install Pyro from source:**

```sh
git clone https://github.com/pyro-ppl/pyro
cd pyro
pip install .  # pip install .[extras] for running models in examples/tutorials
```

## Running Pyro from a Docker Container

Refer to the instructions [here](docker/README.md).

## Citation
If you use Pyro, please consider citing:
```
@article{bingham2019pyro,
  author    = {Eli Bingham and
               Jonathan P. Chen and
               Martin Jankowiak and
               Fritz Obermeyer and
               Neeraj Pradhan and
               Theofanis Karaletsos and
               Rohit Singh and
               Paul A. Szerlip and
               Paul Horsfall and
               Noah D. Goodman},
  title     = {Pyro: Deep Universal Probabilistic Programming},
  journal   = {J. Mach. Learn. Res.},
  volume    = {20},
  pages     = {28:1--28:6},
  year      = {2019},
  url       = {http://jmlr.org/papers/v20/18-403.html}
}
```


# Prefect

Prefect is an orchestration and observation platform for building and reacting to workflows.
It's the simplest way to transform Python code into an interactive workflow application.

With Prefect you can standardize workflow deployment across your organization.

You can build resilient, dynamic workflows that react to the world around them and recover from unexpected changes.

With just a few decorators, Prefect supercharges your code with features like automatic retries, distributed execution, scheduling, caching, and much more.

Workflow activity is tracked and can be monitored with a self-hosted [Prefect server](https://docs.prefect.io/latest/guides/host/) instance or managed [Prefect Cloud](https://www.prefect.io/cloud-vs-oss?utm_source=oss&utm_medium=oss&utm_campaign=oss_gh_repo&utm_term=none&utm_content=none) dashboard.

## Getting started

Prefect requires Python 3.9 or later. To [install the latest or upgrade to the latest version of Prefect](https://docs.prefect.io/getting-started/installation/), run the following command:

```bash
pip install -U prefect
```

Then create and run a Python file that uses Prefect `flow` and `task` decorators to orchestrate and observe your workflow - in this case, a simple script that fetches the number of GitHub stars from a repository:

```python
from prefect import flow, task
from typing import list
import httpx

@task(log_prints=True)
def get_stars(repo: str):
    url = f"https://api.github.com/repos/{repo}"
    count = httpx.get(url).json()["stargazers_count"]
    print(f"{repo} has {count} stars!")

@flow(name="GitHub Stars")
def github_stars(repos: list[str]):
    for repo in repos:
        get_stars(repo)

# run the flow!
if __name__=="__main__":
    github_stars(["PrefectHQ/Prefect"])
```

Fire up the Prefect UI to see what happened:

```bash
prefect server start
```

![Prefect UI dashboard](https://github.com/PrefectHQ/prefect/blob/main/docs/images/cloud-overview1.png?raw=true)

To run your workflow on a schedule, turn it into a deployment and schedule it to run every minute by changing the last line of your script to the following:

```python
if __name__ == "__main__":
    github_stars.serve(name="first-deployment", cron="* * * * *")
```

You now have a server running locally that is looking for scheduled deployments!
Additionally you can run your workflow manually from the UI or CLI - and if you're using Prefect Cloud, you can even run deployments in response to [events](https://docs.prefect.io/latest/concepts/automations/).

## Prefect Cloud

Stop worrying about your workflows.
Prefect Cloud allows you to centrally deploy, monitor, and manage the data workflows you support. With managed orchestration, automations, and webhooks, all backed by enterprise-class security, build production-ready code quickly and reliably.

Read more about Prefect Cloud [here](https://www.prefect.io/cloud-vs-oss?utm_source=oss&utm_medium=oss&utm_campaign=oss_gh_repo&utm_term=none&utm_content=none) or sign up to [try it for yourself](https://app.prefect.cloud?utm_source=oss&utm_medium=oss&utm_campaign=oss_gh_repo&utm_term=none&utm_content=none).

![Prefect Automations](https://github.com/PrefectHQ/prefect/blob/main/docs/images/automations-1.png?raw=true)
![Prefect Automations](https://github.com/PrefectHQ/prefect/blob/main/docs/images/automations-2.png?raw=true)
![Prefect Automations](https://github.com/PrefectHQ/prefect/blob/main/docs/images/automations-4.png?raw=true)

## prefect-client

If your use case is geared towards communicating with Prefect Cloud or a remote Prefect server, check out our
[prefect-client](https://pypi.org/project/prefect-client/). It is a lighter-weight option for accessing client-side functionality in the Prefect SDK and is ideal for use in ephemeral execution environments.

## Next steps

- Check out the [Docs](https://docs.prefect.io/).
- Join the {Prefect Slack community](https://prefect.io/slack).
- Learn how to [contribute to Prefect](https://docs.prefect.io/contributing/overview/).


Robot Framework
===============

.. contents::
   :local:

Introduction
------------

`Robot Framework <http://robotframework.org>`_ |r| is a generic open source
automation framework for acceptance testing, acceptance test driven
development (ATDD), and robotic process automation (RPA). It has simple plain
text syntax and it can be extended easily with generic and custom libraries.

Robot Framework is operating system and application independent. It is
implemented using `Python <http://python.org>`_ which is also the primary
language to extend it. The framework has a rich ecosystem around it consisting
of various generic libraries and tools that are developed as separate projects.
For more information about Robot Framework and the ecosystem, see
http://robotframework.org.

Robot Framework project is hosted on GitHub_ where you can find source code,
an issue tracker, and some further documentation. Downloads are hosted on PyPI_.

Robot Framework development is sponsored by non-profit `Robot Framework Foundation
<http://robotframework.org/foundation>`_. If you are using the framework
and benefiting from it, consider joining the foundation to help maintaining
the framework and developing it further.

.. _GitHub: https://github.com/robotframework/robotframework
.. _PyPI: https://pypi.python.org/pypi/robotframework

.. image:: https://img.shields.io/pypi/v/robotframework.svg?label=version
   :target: https://pypi.python.org/pypi/robotframework
   :alt: Latest version

.. image:: https://img.shields.io/pypi/l/robotframework.svg
   :target: http://www.apache.org/licenses/LICENSE-2.0.html
   :alt: License

Installation
------------

If you already have Python_ with `pip <https://pip.pypa.io>`_ installed,
you can simply run::

    pip install robotframework

For more detailed installation instructions, including installing Python, see
`<INSTALL.rst>`__.

Robot Framework requires Python 3.8 or newer and runs also on `PyPy <http://pypy.org>`_.
The latest version that supports Python 3.6 and 3.7 is `Robot Framework 6.1.1`__.
If you need to use Python 2, `Jython <http://jython.org>`_ or
`IronPython <http://ironpython.net>`_, you can use `Robot Framework 4.1.3`__.

__ https://github.com/robotframework/robotframework/tree/v6.1.1#readme
__ https://github.com/robotframework/robotframework/tree/v4.1.3#readme

Example
-------

Below is a simple example test case for testing login to some system.
You can find more examples with links to related demo projects from
http://robotframework.org.

.. code:: robotframework

    *** Settings ***
    Documentation     A test suite with a single test for valid login.
    ...
    ...               This test has a workflow that is created using keywords in
    ...               the imported resource file.
    Resource          login.resource

    *** Test Cases ***
    Valid Login
        Open Browser To Login Page
        Input Username    demo
        Input Password    mode
        Submit Credentials
        Welcome Page Should Be Open
        [Teardown]    Close Browser

Usage
-----

Tests (or tasks) are executed from the command line using the ``robot``
command or by executing the ``robot`` module directly like ``python -m robot`` .

The basic usage is giving a path to a test (or task) file or directory as an
argument with possible command line options before the path::

    robot tests.robot
    robot --variable BROWSER:Firefox --outputdir results path/to/tests/

Additionally, there is the ``rebot`` tool for combining results and otherwise
post-processing outputs::

    rebot --name Example output1.xml output2.xml

Run ``robot --help`` and ``rebot --help`` for more information about the command
line usage. For a complete reference manual see `Robot Framework User Guide`_.

Documentation
-------------

- `Robot Framework User Guide
  <http://robotframework.org/robotframework/#user-guide>`_
- `Standard libraries
  <http://robotframework.org/robotframework/#standard-libraries>`_
- `API documentation <http://robot-framework.readthedocs.org>`_
- `General documentation <http://robotframework.org/>`_

Support and Contact
-------------------

- `Slack <http://slack.robotframework.org/>`_
- `Forum <https://forum.robotframework.org/>`_
- `robotframework-users
  <https://groups.google.com/group/robotframework-users/>`_ mailing list

Contributing
------------

Interested to contribute to Robot Framework? Great! In that case it is a good
start by looking at the `<CONTRIBUTING.rst>`__. If you
do not already have an issue you would like to work on, you can check
issues with `good new issue`__ and `help wanted`__ labels.

Remember also that there are many other tools and libraries in the wider
`Robot Framework ecosystem <http://robotframework.org>`_ that you can
contribute to!

__ https://github.com/robotframework/robotframework/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22
__ https://github.com/robotframework/robotframework/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22

License and Trademark
---------------------

Robot Framework is open source software provided under the `Apache License 2.0`__.
Robot Framework documentation and other similar content use the
`Creative Commons Attribution 3.0 Unported`__ license. Most libraries and tools
in the ecosystem are also open source, but they may use different licenses.

Robot Framework trademark is owned by `Robot Framework Foundation`_.

__ http://apache.org/licenses/LICENSE-2.0
__ http://creativecommons.org/licenses/by/3.0

.. |r| unicode:: U+00AE


<p align="center">
</p>

# AWS SAM CLI

![Apache 2.0 License](https://img.shields.io/github/license/aws/aws-sam-cli)
![SAM CLI Version](https://img.shields.io/github/release/aws/aws-sam-cli.svg?label=CLI%20Version)
![Install](https://img.shields.io/badge/brew-aws/tap/aws--sam--cli-orange)
![pip](https://img.shields.io/badge/pip-aws--sam--cli-9cf)

[Installation](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html) | [Blogs](https://serverlessland.com/blog?tag=AWS%20SAM) | [Videos](https://serverlessland.com/video?tag=AWS%20SAM) | [AWS Docs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html) | [Roadmap](https://github.com/aws/aws-sam-cli/wiki/SAM-CLI-Roadmap) | [Try It Out](https://s12d.com/jKo46elk) | [Slack Us](https://join.slack.com/t/awsdevelopers/shared_invite/zt-yryddays-C9fkWrmguDv0h2EEDzCqvw)

The AWS Serverless Application Model (SAM) CLI is an open-source CLI tool that helps you develop serverless applications containing [Lambda functions](https://aws.amazon.com/lambda/), [Step Functions](https://aws.amazon.com/step-functions/), [API Gateway](https://aws.amazon.com/api-gateway/), [EventBridge](https://aws.amazon.com/eventbridge/), [SQS](https://aws.amazon.com/sqs/), [SNS](https://aws.amazon.com/sns/) and more. Some of the features it provides are:

* **Initialize serverless applications** in minutes with AWS-provided infrastructure templates with `sam init`
* **Compile, build, and package** Lambda functions with provided runtimes and with custom Makefile workflows, for zip and image types of Lambda functions with `sam build`
* **Locally test** a Lambda function and API Gateway easily in a Docker container with `sam local` commands on SAM and CDK applications
* **Sync and test your changes in the cloud** with `sam sync` in your developer environments
* **Deploy** your SAM and CloudFormation templates using `sam deploy`
* Quickly **create pipelines** with prebuilt templates with popular CI/CD systems using `sam pipeline init`
* **Tail CloudWatch logs and X-Ray traces** with `sam logs` and `sam traces`

## Recent blogposts and workshops

* **Speeding up incremental changes with AWS SAM Accelerate and Nested Stacks** - [Read blogpost here](https://s12d.com/wt1ajjwB).

* **Develop Node projects with SAM CLI using esbuild** - and use SAM Accelerate on Typescript projects. [Read blogpost here](https://s12d.com/5Aa6u0o7).

* **Speed up development with SAM Accelerate** - quickly test your changes in the cloud. [Read docs here](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/accelerate.html).

* **AWS Serverless Developer Experience Workshop: A day in a life of a developer** - [This advanced workshop](https://s12d.com/aws-sde-workshop) provides you with an immersive experience as a serverless developer, with hands-on experience building a serverless solution using AWS SAM and SAM CLI.

* **The Complete SAM Workshop** - [This workshop](https://s12d.com/jKo46elk) is a great way to experience the power of SAM and SAM CLI.

* **Getting started with CI/CD? SAM pipelines can help you get started** - [This workshop](https://s12d.com/_JQ48d5T) walks you through the basics.

* **Get started with Serverless Application development using SAM CLI** - [This workshop](https://s12d.com/Tq9ZE-Br) walks you through the basics.

## Get Started

To get started with building SAM-based applications, use the SAM CLI. SAM CLI provides a Lambda-like execution
environment that lets you locally build, test, debug, and deploy [AWS serverless](https://aws.amazon.com/serverless/) applications.

* [Install SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html)
* [Build & Deploy a "Hello World" Web App](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-quick-start.html)
* [Install AWS Toolkit](https://aws.amazon.com/getting-started/tools-sdks/#IDE_and_IDE_Toolkits) to use SAM with your favorite IDEs
* [Tutorials and Workshops](https://serverlessland.com/learn)
* **Powertools for AWS Lambda** is a developer toolkit to implement Serverless best practices and increase developer velocity. Available for [Python](https://awslabs.github.io/aws-lambda-powertools-python), [Java](https://github.com/awslabs/aws-lambda-powertools-java), [TypeScript](https://github.com/awslabs/aws-lambda-powertools-typescript) and [.NET](https://github.com/awslabs/aws-lambda-powertools-dotnet).

**Next Steps:** Learn to build a more complex serverless application.

* [Extract text from images and store it in a database](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-example-s3.html) using Amazon S3 and Amazon Rekognition services.
* [Detect when records are added to a database](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-example-ddb.html) using Amazon DynamoDB database and asynchronous stream processing.
* [Explore popular patterns](https://serverlessland.com/patterns)

## What is this Github repository? 💻

This Github repository contains source code for SAM CLI. Here is the development team talking about this code:

> SAM CLI code is written in Python. Source code is well documented, very modular, with 95% unit test coverage.
It uses this awesome Python library called Click to manage the command line interaction and uses Docker to run Lambda functions locally.
We think you'll like the code base. Clone it and run `make pr` or `./Make -pr` on Windows!

## Related Repositories and Resources

* **SAM Transform** [Open source template specification](https://github.com/aws/serverless-application-model/) that provides shorthand syntax for CloudFormation
* **SAM CLI application templates** Get started quickly with [predefined application templates](https://github.com/aws/aws-sam-cli-app-templates/blob/master/README.md) for all supported runtimes and languages, used by `sam init`
* **Lambda Builders** [Lambda builder tools](https://github.com/aws/aws-lambda-builders) for supported runtimes and custom build workflows, used by `sam build`
* **Build and local emulation images for CI/CD tools** [Build container images](https://gallery.ecr.aws/sam/) to use with CI/CD tasks

## Contribute to SAM

We love our contributors ❤ We have over 100 contributors who have built various parts of the product.
Read this [testimonial from @ndobryanskyy](https://www.lohika.com/aws-sam-my-exciting-first-open-source-experience/) to learn
more about what it was like contributing to SAM.

Depending on your interest and skill, you can help build the different parts of the SAM project;

**Enhance the SAM Specification**

Make pull requests, report bugs, and share ideas to improve the full SAM template specification.
Source code is located on Github at [aws/serverless-application-model](https://github.com/aws/serverless-application-model).
Read the [SAM Specification Contributing Guide](https://github.com/aws/serverless-application-model/blob/master/CONTRIBUTING.md)
to get started.

**Strengthen SAM CLI**

Add new commands, enhance existing ones, report bugs, or request new features for the SAM CLI.
Source code is located on Github at [aws/aws-sam-cli](https://github.com/aws/aws-sam-cli). Read the [SAM CLI Contributing Guide](https://github.com/aws/aws-sam-cli/blob/develop/CONTRIBUTING.md) to
get started.

**Update SAM Developer Guide**

[SAM Developer Guide](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/index.html) provides a comprehensive getting started guide and reference documentation.
Source code is located on Github at [awsdocs/aws-sam-developer-guide](https://github.com/awsdocs/aws-sam-developer-guide).
Read the [SAM Documentation Contribution Guide](https://github.com/awsdocs/aws-sam-developer-guide/blob/master/CONTRIBUTING.md) to get
started.

### Join the SAM Community on Slack

[Join the SAM developers channel (#samdev)](https://join.slack.com/t/awsdevelopers/shared_invite/zt-yryddays-C9fkWrmguDv0h2EEDzCqvw) on Slack to collaborate with fellow community members and the AWS SAM team.


.. image:: https://github.com/django-oscar/django-oscar/raw/master/docs/images/logos/oscar.png
    :target: http://oscarcommerce.com

===================================
Domain-driven e-commerce for Django
===================================

Oscar is an e-commerce framework for Django designed for building domain-driven
sites.  It is structured such that any part of the core functionality can be
customised to suit the needs of your project.  This allows a wide range of
e-commerce requirements to be handled, from large-scale B2C sites to complex B2B
sites rich in domain-specific business logic.

Contents:

.. contents:: :local:

.. image:: https://github.com/django-oscar/django-oscar/raw/master/docs/images/screenshots/oscarcommerce.thumb.png
    :target: http://oscarcommerce.com

.. image:: https://github.com/django-oscar/django-oscar/raw/master/docs/images/screenshots/readthedocs.thumb.png
    :target: https://django-oscar.readthedocs.io/en/latest/

Further reading:

* `Official homepage`_
* `Sandbox site`_ (automatically deployed via the official docker sandbox image)
* `Documentation`_ on the excellent `readthedocs.org`_
* `Docker image`_ on http://hub.docker.com/
* `django-oscar group`_ - mailing list for questions and announcements
* `Twitter account for news and updates`_
* `Discord`_
* `PyPI page`_
* `Transifex project`_ - translating Oscar made easy

.. start-no-pypi

Continuous integration status:

.. image:: https://github.com/django-oscar/django-oscar/workflows/Tests/badge.svg

.. image:: http://codecov.io/github/django-oscar/django-oscar/coverage.svg?branch=master
    :alt: Coverage
    :target: http://codecov.io/github/django-oscar/django-oscar?branch=master

.. image:: https://requires.io/github/django-oscar/django-oscar/requirements.svg?branch=master
     :target: https://requires.io/github/django-oscar/django-oscar/requirements/?branch=master
     :alt: Requirements Status

PyPI status:

.. image:: https://img.shields.io/pypi/v/django-oscar.svg
    :target: https://pypi.python.org/pypi/django-oscar/

Docs status:

.. image:: https://readthedocs.org/projects/django-oscar/badge/
   :target: https://readthedocs.org/projects/django-oscar/
   :alt: Documentation Status

.. end-no-pypi

.. _`Official homepage`: http://oscarcommerce.com
.. _`Sandbox site`: https://latest.oscarcommerce.com
.. _`Docker image`: https://hub.docker.com/r/oscarcommerce/django-oscar-sandbox/
.. _`Documentation`: https://docs.oscarcommerce.com/en/latest/
.. _`readthedocs.org`: http://readthedocs.org
.. _`Twitter account for news and updates`: https://twitter.com/#!/django_oscar
.. _`django-oscar group`: https://groups.google.com/forum/?fromgroups#!forum/django-oscar
.. _`PyPI page`: https://pypi.python.org/pypi/django-oscar/
.. _`Transifex project`: https://www.transifex.com/projects/p/django-oscar/
.. _`Discord`: https://discord.gg/NMwfZuJnJZ

Core team:

- `David Winterbottom`_ (Twitter `@codeinthehole`_)
- `Maik Hoepfel`_ (Twitter `@maikhoepfel`_)
- `Markus Bertheau`_
- `Michael van Tellingen`_
- `Alexander Gaevsky`_
- `Samir Shah`_

.. _`David Winterbottom`: https://github.com/codeinthehole
.. _`@codeinthehole`: https://twitter.com/codeinthehole
.. _`Maik Hoepfel`: https://github.com/maikhoepfel
.. _`@maikhoepfel`: https://twitter.com/maikhoepfel
.. _`Markus Bertheau`: https://github.com/mbertheau
.. _`Michael van Tellingen`: https://github.com/mvantellingen
.. _`Alexander Gaevsky`: https://github.com/sasha0
.. _`Samir Shah`: https://github.com/solarissmoke

Supported versions
------------------

The currently supported versions of Oscar are:

+---------+----------------+
| Version | End of support |
+=========+================+
| 3.2 LTS | January 2026   |
+---------+----------------+
| 3.1     | April 2022     |
+---------+----------------+
| 3.0     | May 2021       |
+---------+----------------+
| 2.2 LTS | August 2023    |
+---------+----------------+

Supported versions are eligible for fixes for data loss bugs and security issues. Releases designated as
Long-term support (LTS) releases will receive support for an extended period of 3 years from their release date.

Screenshots
-----------

Sandbox
~~~~~~~

These are screenshots from the 'sandbox' example site that ships with
Oscar.  It sports a simple design built with Twitter's Bootstrap_ and provides a
good starting point for rapidly building elegant e-commerce sites.

.. _Bootstrap: https://getbootstrap.com/

.. image:: https://github.com/django-oscar/django-oscar/raw/master/docs/images/screenshots/browse.thumb.png
    :target: https://github.com/django-oscar/django-oscar/raw/master/docs/images/screenshots/browse.png

.. image:: https://github.com/django-oscar/django-oscar/raw/master/docs/images/screenshots/detail.thumb.png
    :target: https://github.com/django-oscar/django-oscar/raw/master/docs/images/screenshots/detail.png

.. image:: https://github.com/django-oscar/django-oscar/raw/master/docs/images/screenshots/basket.thumb.png
    :target: https://github.com/django-oscar/django-oscar/raw/master/docs/images/screenshots/basket.png

.. image:: https://github.com/django-oscar/django-oscar/raw/master/docs/images/screenshots/dashboard.thumb.png
    :target: https://github.com/django-oscar/django-oscar/raw/master/docs/images/screenshots/dashboard.png

The sandbox site is also available to browse at https://latest.oscarcommerce.com.

The sandbox site can be set-up locally `in 5 commands`_.  Want to
make changes?  Check out the `contributing guidelines`_.

.. _`in 5 commands`: https://django-oscar.readthedocs.io/en/latest/internals/sandbox.html#run-the-sandbox-locally
.. _`contributing guidelines`: https://django-oscar.readthedocs.io/en/latest/internals/contributing/index.html

Extensions
----------

The following extensions are stable and ready for use:

* django-oscar-api_ - RESTful JSON API for django-oscar

* django-oscar-odin_ - Odin Resources and mappings to Oscar models

* django-oscar-adyen_ - Integration with the Adyen payment gateway

* django-oscar-datacash_ - Integration with the DataCash_ payment gateway

* django-oscar-paypal_ - Integration with PayPal.  This currently supports both
  `Express Checkout`_ and `PayFlow Pro`_.

* django-oscar-paymentexpress_ - Integration with the `Payment Express`_ payment
  gateway

* django-oscar-accounts_ - Managed accounts (can be used for giftcard
  functionality and loyalty schemes)

* django-oscar-stores_ - Physical stores integration (opening hours, store
  locator etc)

* django-oscar-sagepay-direct_ - Integration with "DIRECT" part of Sagepay's API

* django_oscar_docdata_ - Integration with Docdata_ payment gateway.

* django_oscar_invoices_ - Invoices or receipts generation for the
  Oscar

.. _django-oscar-api: https://github.com/django-oscar/django-oscar-api
.. _django-oscar-odin: https://github.com/django-oscar/django-oscar-odin
.. _django-oscar-adyen: https://github.com/django-oscar/django-oscar-adyen
.. _django-oscar-datacash: https://github.com/django-oscar/django-oscar-datacash
.. _django-oscar-paymentexpress: https://github.com/django-oscar/django-oscar-paymentexpress
.. _`Payment Express`: http://www.paymentexpress.com
.. _DataCash: http://www.datacash.com/
.. _django-oscar-paypal: https://github.com/django-oscar/django-oscar-paypal
.. _`Express Checkout`: https://www.paypal.com/uk/cgi-bin/webscr?cmd=_additional-payment-ref-impl1
.. _`PayFlow Pro`: https://merchant.paypal.com/us/cgi-bin/?cmd=_render-content&content_ID=merchant/payment_gateway
.. _django-oscar-accounts: https://github.com/django-oscar/django-oscar-accounts
.. _django-oscar-easyrec: https://github.com/django-oscar/django-oscar-easyrec
.. _EasyRec: http://easyrec.org/
.. _django-oscar-stores: https://github.com/django-oscar/django-oscar-stores
.. _django-oscar-sagepay-direct: https://github.com/django-oscar/django-oscar-sagepay-direct
.. _eWay: https://www.eway.com.au
.. _django_oscar_docdata: https://github.com/django-oscar/django-oscar-docdata
.. _Docdata: https://www.docdatapayments.com/
.. _django_oscar_invoices: https://github.com/django-oscar/django-oscar-invoices

The following are community-written extensions:

* django-oscar-payments_ - Pluggable payments for Oscar

* oscar-sagepay_ - Payment integration with Sage Pay

* django-oscar-support_ - Customer services and ticketing plugin for Oscar

* django-oscar-api-checkout_ - Oscar API Checkout is a layer on top of
  django-oscar and django-oscar-api, adding support for more complex and
  multiple payment options during an API checkout.

* django-oscar-bundles_ - Oscar Bundles adds multi-product bundles to
  django-oscar.

* django-oscar-bluelight_ - `Bluelight Specials`_ is a layer on-top of
  django-oscar that adds support for more complex offers and vouchers,
  including conjunctive and disjunctive compound conditions.

* django-oscar-cch_ - Oscar CCH is a plugin for django-oscar adding support
  for calculating taxes using the Wolters Kluwer `CCH Sales Tax Office`_ SOAP
  API.

* django-oscar-cybersource_ - Oscar CyberSource is a plugin for Oscar API
  Checkout that makes it possible to use
  `CyberSource Secure Acceptance Silent Order Post`_ as an order payment
  method.

* django-oscar-wfrs_ - Oscar WFRS is a plugin for django-oscar-api-checkout_
  that makes it possible to use `Wells Fargo Retail Services`_ as an order
  payment method.

* django-oscar-zarinpal-gateway_ - Payment gateway integration for Zarinpal Payments in django-oscar. Zarinpal Payments is a large payment gateway based in The I.R. Iran .

Let us know if you're writing a new one!

.. _django-oscar-payments: https://github.com/Lacrymology/django-oscar-payments
.. _oscar-sagepay: https://github.com/udox/oscar-sagepay
.. _django-oscar-support: https://github.com/SalahAdDin/django-oscar-support
.. _django-oscar-api-checkout: https://github.com/thelabnyc/django-oscar-api-checkout
.. _django-oscar-bundles: https://github.com/thelabnyc/django-oscar-bundles
.. _django-oscar-bluelight: https://github.com/thelabnyc/django-oscar-bluelight
.. _`Bluelight Specials`: https://en.wiktionary.org/wiki/blue-light_special
.. _django-oscar-cch: https://github.com/thelabnyc/django-oscar-cch
.. _`CCH Sales Tax Office`: http://www.salestax.com/solutions/calculation/cch-salestax-office/
.. _django-oscar-cybersource: https://github.com/thelabnyc/django-oscar-cybersource
.. _`CyberSource Secure Acceptance Silent Order Post`: https://www.cybersource.com/products/payment_security/secure_acceptance_silent_order_post/
.. _django-oscar-wfrs: https://github.com/thelabnyc/django-oscar-wfrs
.. _`Wells Fargo Retail Services`: https://retailservices.wellsfargo.com/
.. _django-oscar-zarinpal-gateway: https://github.com/mojtabaakbari221b/django-oscar-zarinpal-gateway

Videos
------

Videos with talks about Oscar:

* `An introduction to Django-oscar`_ by `David Winterbottom`_, DjangoCon Europe 2014
* `Oscar and the art of transactional Django applications`_ by `David Winterbottom`_, PyCon PL 2014
* `The Tale of Oscar and the API`_ by `Kees Hink`_, PyGrunn 2017

.. _`An introduction to Django-oscar`: https://youtu.be/o4ol6EzGDSw
.. _`Oscar and the art of transactional Django applications`: https://youtu.be/datKUNTKYz8
.. _`The Tale of Oscar and the API`: https://youtu.be/YPnKoiyGIHM
.. _`Kees Hink`: https://github.com/khink

License
-------

Oscar is released under the permissive `New BSD license`_ (see summary_).

.. _summary: https://tldrlegal.com/license/bsd-3-clause-license-(revised)

.. _`New BSD license`: https://github.com/django-oscar/django-oscar/blob/master/LICENSE

Contributing to the Project
---------------------------

We welcome contributions to the project! Whether it's a bug fix, a new feature, or just some documentation improvements, your contributions are greatly appreciated.

To contribute, please follow these steps:

Fork the project repository on GitHub.
Clone your forked repository to your local machine.
Create a new branch for your changes.
Make your changes, and commit them with clear commit messages.
Push your changes to your forked repository.
Open a pull request on the original project repository, explaining your changes.
Please note that all contributions are subject to review, and may be modified or rejected if they do not meet the project's standards.

Code of Conduct
---------------

We want everyone involved in the project to feel safe and respected, regardless of their background or identity. As such, we have adopted the following Code of Conduct:

Our Pledge
----------

In the interest of fostering an open and welcoming environment, we pledge to:

Be friendly and welcoming to all contributors.
Respect differing viewpoints and experiences.
Accept constructive criticism and feedback graciously.
Focus on what is best for the community and the project.

Our Standards
-------------

We expect all contributors to:

Use welcoming and inclusive language.
Be respectful of differing viewpoints and experiences.
Gracefully accept constructive criticism.
Focus on what is best for the community and the project.

Our Responsibilities
--------------------

Project maintainers are responsible for:

Enforcing the Code of Conduct.
Investigating and addressing reported violations of the Code of Conduct.
Making clear and fair decisions about disciplinary actions for violations of the Code of Conduct.
Scope
This Code of Conduct applies to all contributors, both online and offline, in all project spaces, including but not limited to project forums, mailing lists, GitHub repositories, and in-person events.

Enforcement
-----------

If you witness or experience unacceptable behavior, or have any other concerns, please notify the project maintainers at viggo@highbiza.nl & joey@highbiza.nl. All reports will be kept confidential, and the project maintainers will work with you to determine a resolution.

We reserve the right to take any action deemed necessary to enforce this Code of Conduct, including but not limited to warning the offender, banning the offender from the project's spaces, or reporting the offender to relevant authorities.
Case studies
------------

Oscar is still in active development but is used in production by a range of
companies, from large multinationals to small, boutique stores. See
http://oscarcommerce.com/cases.html for an overview.

Many more on the way.  If you use Oscar in production, please `let us know`_.

.. _`let us know`: https://github.com/django-oscar/oscarcommerce.com/issues

Looking for commercial support?
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

If you are interested in having an Oscar project built for you, or for
development of an existing Oscar site then please get in touch via `info@oscarcommerce.com`_.

.. _`info@oscarcommerce.com`: mailto:info@oscarcommerce.com


EdgeDB

  Quickstart
    •
  Website
    •
  Docs
    •
  Playground
    •
  Blog
    •
  Discord
    •
  Twitter

What is EdgeDB?

    EdgeDB is a new kind of database

    that takes the best parts of

    relational databases, graph

    databases, and ORMs. We call it

a graph-relational database.

🧩 Types, not tables 🧩

Schema is the foundation of your application. It should be something you can
read, write, and understand.

Forget foreign keys; tabular data modeling is a relic of an older age, and it
[isn't compatible](https://en.wikipedia.org/wiki/Object%E2%80%93relational_impedance_mismatch)
with modern languages. Instead, EdgeDB thinks about schema the same way you do:
as **object types** containing **properties** connected by **links**.

```elm
type Person {
  required name: str;
}

type Movie {
  required title: str;
  multi actors: Person;
}
```

This example is intentionally simple, but EdgeDB supports everything you'd
expect from your database: a strict type system, indexes, constraints, computed
properties, stored procedures...the list goes on. Plus it gives you some shiny
new features too: link properties, schema mixins, and best-in-class JSON
support. Read the [schema docs](https://www.edgedb.com/docs/datamodel/index)
for details.

🌳 Objects, not rows 🌳

EdgeDB's super-powered query language EdgeQL is designed as a ground-up
redesign of SQL. EdgeQL queries produce rich, structured objects, not flat
lists of rows. Deeply fetching related objects is painless...bye, bye, JOINs.

```elm
select Movie {
  title,
  actors: {
    name
  }
}
filter .title = "The Matrix"
```

EdgeQL queries are also _composable_; you can use one EdgeQL query as an
expression inside another. This property makes things like _subqueries_ and
_nested mutations_ a breeze.

```elm
insert Movie {
  title := "The Matrix Resurrections",
  actors := (
    select Person
    filter .name in {
      'Keanu Reeves',
      'Carrie-Anne Moss',
      'Laurence Fishburne'
    }
  )
}
```

There's a lot more to EdgeQL: a comprehensive standard library, computed
properties, polymorphic queries, `with` blocks, transactions, and much more.
Read the [EdgeQL docs](https://www.edgedb.com/docs/edgeql/index) for the full
picture.

🦋 More than a mapper 🦋

While EdgeDB solves the same problems as ORM libraries, it's so much more. It's
a full-fledged database with a
[powerful and elegant query language](https://www.edgedb.com/docs/edgeql/index), a
[migrations system](https://www.edgedb.com/docs/guides/migrations/index), a
[suite of client libraries](https://www.edgedb.com/docs/clients/index) in
different languages, a
[command line tool](https://www.edgedb.com/docs/cli/index), and—coming soon—a
cloud hosting platform. The goal is to rethink every aspect of how developers
model, migrate, manage, and query their database.

Here's a taste-test of EdgeDB's next-level developer experience: you can
install our CLI, spin up an instance, and open an interactive EdgeQL shell with
just three commands.

```
$ curl --proto '=https' --tlsv1.2 -sSf https://sh.edgedb.com | sh
$ edgedb project init
$ edgedb
edgedb> select "Hello world!"
```

Windows users: use this Powershell command to install the CLI.

```
PS> iwr https://ps1.edgedb.com -useb | iex
```

## Get started

To start learning about EdgeDB, check out the following resources:

- **[The quickstart](https://www.edgedb.com/docs/guides/quickstart)**. If
  you're just starting out, the 10-minute quickstart guide is the fastest way
  to get up and running.
- **[EdgeDB Cloud 🌤](https://www.edgedb.com/cloud)**. The best
  most effortless way to host your EdgeDB database in the cloud.
- **[The interactive tutorial](https://www.edgedb.com/tutorial)**. For a
  structured deep-dive into the EdgeQL query language, try the web-based
  tutorial— no need to install anything.
- **[The e-book](https://www.edgedb.com/easy-edgedb)**. For the most
  comprehensive walkthrough of EdgeDB concepts, check out our illustrated
  e-book [Easy EdgeDB](https://www.edgedb.com/easy-edgedb). It's designed to
  walk a total beginner through EdgeDB in its entirety, from the basics through
  advanced concepts.
- **The docs.** Jump straight into the docs for
  [schema modeling](https://www.edgedb.com/docs/datamodel/index) or
  [EdgeQL](https://www.edgedb.com/docs/edgeql/index)!

## Contributing

PRs are always welcome! To get started, follow
[this guide](https://www.edgedb.com/docs/internals/dev) to build EdgeDB from
source on your local machine.

[File an issue 👉](https://github.com/edgedb/edgedb/issues/new/choose)

[Start a Discussion 👉](https://github.com/edgedb/edgedb/discussions/new)

[Join the discord 👉](https://discord.gg/umUueND6ag)

## License

The code in this repository is developed and distributed under the
Apache 2.0 license. See [LICENSE](LICENSE) for details.