New features sc2py - steemconnect2 with python

What is sc2py ?

Sc2py is the first python library written for SteemConnect2, To learn more, check my first contribution

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

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
                }],

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)
                }],

class Follow(Unfollow):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.what = "blog"

class Mute(Unfollow):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.what = "ignore"

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)
            }],

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)
                }],

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]
                                }
                        ]
                    ]
                }],

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
            }
        ],

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,
            }
        ],

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

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:

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

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

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

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

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

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

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;

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

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

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.

---

Posted on Utopian.io - Rewarding Open Source Contributors

---