### What is sc2py ?
Sc2py is the first python library written for SteemConnect2, To learn more, check [my first contribution](https://utopian.io/utopian-io/@hakancelik/new-project-named-sc2py-to-steemconnect2-with-python)

### New Features
#### What feature(s) did you add?

I increased understanding, use and readability of codes of project, in addition I added some features,
let's get to know these features and I changed in old features like vote,follow,unfollow,post.

- Mute
> You can get a user to be muted in.

- Reblog
> You can reblog a post.

- Comment_options
> With this option you can add data like this to any post.
> "root_author":"bkatipoglu1","root_permlink":"endustri-40","max_accepted_payout":"100000.000 SBD","percent_steem_dollars":10000,"allow_replies":true,"allow_votes":true,"allow_curation_rewards":true,"beneficiaries":[{"account":"coogger","weight":1000}]

- DeleteComment
> We can delete any post.

- ClaimRewardBalance
> We can transfer our reward balance to wallet.


#### How did you implement it/them?
- [This commit includes new features](https://github.com/hakancelik96/sc2py/commit/928ca14a5013bd2a7cb2d06e3a720d58ee95c611)

```python
import json

class Vote:
    def __init__(self, voter, author, permlink, weight = 100):
        self.voter = voter
        self.author = author
        self.permlink = permlink
        self.weight = weight

    @property
    def json(self):
        return [
            "vote",
                {
                    "voter":"{}".format(self.voter),
                    "author":"{}".format(self.author),
                    "permlink":"{}".format(self.permlink),
                    "weight":self.weight * 100
                }],
```
```python
class Unfollow:
    def __init__(self,follower,following,what = []):
        self.follower = follower
        self.following = following
        self.what = what

    @property
    def json(self):
        follow_json = [
            "follow",
                {
                    "follower":"{}".format(self.follower),
                    "following":"{}".format(self.following),
                    "what":["{}".format(self.what)]
                }]
        return [
            "custom_json",
                {
                    "required_auths":[],
                    "required_posting_auths":["{}".format(self.follower)],
                    "id":"follow",
                    "json":json.dumps(follow_json)
                }],

```
```python
class Follow(Unfollow):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.what = "blog"
```
```python
class Mute(Unfollow):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.what = "ignore"
```
```python
class Reblog:

    def __init__(self, account, author, permlink):
        self.account = account
        self.author = author
        self.permlink = permlink

    @property
    def json(self):
        reblog_json = [
            "reblog",
                {
                    "account":"{}".format(self.account),
                    "author":"{}".format(self.author),
                    "permlink":"{}".format(self.permlink)
                }]
        return [
            "custom_json",
            {
                "required_auths":[],
                "required_posting_auths":["{}".format(self.account)],
                "id":"follow",
                "json":json.dumps(reblog_json)
            }],
```
```python
class Comment:

    def __init__(self,parent_permlink,author,permlink,title,body,json_metadata):
        self.parent_permlink = parent_permlink
        self.author = author
        self.permlink = permlink
        self.title = title
        self.body = body
        self.json_metadata = json_metadata

    @property
    def json(self):
        return [
            "comment",
                {
                    "parent_author":"",
                    "parent_permlink":"{}".format(self.parent_permlink),
                    "author":"{}".format(self.author),
                    "permlink":"{}".format(self.permlink),
                    "title":"{}".format(self.title),
                    "body":"{}".format(self.body),
                    "json_metadata":json.dumps(self.json_metadata)
                }],
```
```python
class Comment_options:

    def __init__(self,author,
        permlink,
        beneficiaries,
        max_accepted_payout = 100000.000,
        percent_steem_dollars = 10000,
        allow_votes = True,
        allow_curation_rewards = True
        ):
        self.author = author
        self.permlink = permlink
        self.beneficiaries = beneficiaries
        self.max_accepted_payout = max_accepted_payout
        self.percent_steem_dollars = percent_steem_dollars
        self.allow_votes = allow_votes
        self.allow_curation_rewards = allow_curation_rewards

    @property
    def json(self):
        return [
            "comment_options",
                {
                    "author":"{}".format(self.author),
                    "permlink":"{}".format(self.permlink),
                    "max_accepted_payout":"{} SBD".format(self.max_accepted_payout),
                    "percent_steem_dollars":self.percent_steem_dollars,
                    "allow_votes":self.allow_votes,
                    "allow_curation_rewards":self.allow_curation_rewards,
                    "extensions":[
                        [
                            0,
                                {
                                    "beneficiaries":[self.beneficiaries]
                                }
                        ]
                    ]
                }],
```
```python
class DeleteComment:

    def __init__(self, author, permlink):
        self.author = author
        self.permlink = permlink

    @property
    def json(self):
        return [
            "delete_comment", {
                "author": self.author,
                "permlink": self.permlink
            }
        ],
```
```python
class ClaimRewardBalance:

    def __init__(self, account, reward_steem, reward_sbd, reward_vests):
        self.account = account
        self.reward_steem = reward_steem
        self.reward_vests = reward_vests
        self.reward_sbd = reward_sbd

    @property
    def json(self):
        return [
            "claim_reward_balance", {
                "account": self.account,
                "reward_steem": self.reward_steem,
                "reward_sbd": self.reward_sbd,
                "reward_vests": self.reward_vests,
            }
        ],
```
```python
class Operations:

    def __init__(self,json):
        self.payload = {"operations":json}

    @property
    def json(self):
        return json.dumps(self.payload).encode(encoding='utf-8')
```

### How to use it or these new features ?

### Installation
`pip install sc2py`

### update
`pip install sc2py -U`


#### First let's include the library in our project

```python
from sc2py.sc2py import Sc2
from sc2py.operations import Vote
from sc2py.operations import Unfollow
from sc2py.operations import Follow
from sc2py.operations import Mute
from sc2py.operations import Reblog
from sc2py.operations import Comment
from sc2py.operations import Comment_options
from sc2py.operations import DeleteComment
from sc2py.operations import ClaimRewardBalance
from sc2py.operations import Operations
```

### ####

The Vote() method will cast a vote on the specified post or comment from the current user:

```python
vote = Vote(voter:str, author:str, permlink:str, weight:int)
json_data = Operations(json = vote.json).json
response = Sc2(token = "your_access_token",data = json_data).run
if response.status_code == 200:
    print("Your post upvoted")
```
Parameters:
- voter: The Steem username of the current user.
- author: The Steem username of the author of the post or comment.
- permlink: The link to the post or comment on which to vote. This is the portion of the URL after the last "/". For example the "permlink" for this post: https://steemit.com/steem/@ned/announcing-smart-media-tokens-smts would be "announcing-smart-media-tokens-smts".
- weight: The weight of the vote. 100 equale a 100% vote.

#### Follow

```python
follow = Follow(follower:str,following:str)
json_data = Operations(json = follow.json).json
response = Sc2(token = "your_access_token",data = json_data).run
if response.status_code != 200:
    print(response.text)
```

#### Unfollow

```python
unfollow = Unfollow(follower:str,following:str)
json_data = Operations(json = unfollow.json).json
response = Sc2(token = "your_access_token",data = json_data).run
if response.status_code != 200:
    print(response.text)
```

#### Mute

```python
mute = Mute(follower:str,following:str)
json_data = Operations(json = mute.json).json
response = Sc2(token = "your_access_token",data = json_data).run
if response.status_code != 200:
    print(response.text)
```

#### Reblog

```python
reblog = Reblog(account:str, author:str, permlink:str)
json_data = Operations(json = reblog.json).json
response = Sc2(token = "your_access_token",data = json_data).run
if response.status_code != 200:
    print(response.text)
```


#### Comment

```python
comment = Comment(parent_permlink:str,author:str,permlink:str,title:str,body:str,json_metadata:dict)
json_data = Operations(json = comment.json).json
response = Sc2(token = "your_access_token",data = json_data).run
if response.status_code != 200:
    print(response.text)
```

#### Comment with Comment_options

```python
comment = Comment(parent_permlink:str,author:str,permlink:str,title:str,body:str,json_metadata:dict)
comment_options = Comment_options(
            author:str,
            permlink:str,
            beneficiaries:dict to tuble or list
            )
jsons = comment.json+comment_options.json
json_data = Operations(json = jsons).json
response = Sc2(token = "your_access_token",data = json_data).run
if response.status_code != 200:
    print(response.text)
```


##### Example;

```python
json_metadata = {
	"format":"markdown",
    "tags":["coogger","python","django"],
    "app":"coogger/1.3.0",
    "community":"coogger",
    "content":{
    	 "status":approved,
    	 "dor":"2.3,
    	  "content_list":"coogger"
		  },
    "mod":{
    		"user":"pars11",
    		"cooggerup":True
			},
	}
comment = Comment(
	parent_permlink = "coogger",
	author = "hakancelik",
	permlink = "permlink",
	title = "title",
	body = "body",
	json_metadata = json_metadata,
)
comment_options = Comment_options(
	author = "pars11",
	permlink = "permlink",
	beneficiaries = {"account":"coogger","weight":100},{"account":"hakancelik","weight":100} # 100 meas 10%
	)
jsons = comment.json+comment_options.json
op = Operations(json = jsons).json
Sc2(token = "token",data = op).run
```

#### DeleteComment

```python
delete_comment = DeleteComment(author:str, permlink:str)
json_data = Operations(json = delete_comment.json).json
response = Sc2(token = "your_access_token",data = json_data).run
if response.status_code != 200:
    print(response.text)
```

#### ClaimRewardBalance

```python
claim_reward_balance = ClaimRewardBalance(account:str, reward_steem:str, reward_sbd:str, reward_vests:str)
json_data = Operations(json = claim_reward_balance.json).json
response = Sc2(token = "your_access_token",data = json_data).run
if response.status_code != 200:
    print(response.text)
```


### Roadmap
The fact that the project is over with the addition of these features, because all the features added, but if I learn other features I will add them.

### How to contribute?
You can notify me of missing features.


<br /><hr/><em>Posted on <a href="https://utopian.io/utopian-io/@hakancelik/new-features-sc2py-steemconnect2-with-python">Utopian.io -  Rewarding Open Source Contributors</a></em><hr/>