Python Forum
Are braces rather than indentation ever wanted?
Thread Rating:
  • 0 Vote(s) - 0 Average
  • 1
  • 2
  • 3
  • 4
  • 5
Are braces rather than indentation ever wanted?
#1
I have a small application that can convert indented python3 code into the equivalent code with braces {} and back again to indented python.

Here is an example of aby.py from my python3 windows installation.

It needs more work (the output needs better layout of spaces etc) but in principal it works. 

I can see it being useful to people with C++/JAVA background that prefer to work in the braces style.

Also, I noticed a couple of days ago this link http://python-with-braces.appspot.com/

It seems to require a complete installation of python 2.x? What I'm proposing doesn't require changes to installation. But maybe my convertor could work alongside it, does anyone use it?


I'd like to develop it further but I don't know what interest there would be in it, it's only a sideline in what I'm currently doing but it does interest me.. 


"""Abstract Base Classes (ABCs) according to PEP 3119.""" ;
from _weakrefset import    WeakSet  ;
def abstractmethod (
   funcobj
) :
{
 funcobj . __isabstractmethod__ = True ;
 return    funcobj ;
}
;
class abstractclassmethod (   classmethod ) :
{
 __isabstractmethod__ = True ;
 def __init__ (
    self
 ,  callable
 ) :
 {
  callable . __isabstractmethod__ = True ;
  super ( ) . __init__ ( callable ) ;
 }
 ;
}
;
class abstractstaticmethod (   staticmethod ) :
{
 __isabstractmethod__ = True ;
 def __init__ (
    self
 ,  callable
 ) :
 {
  callable . __isabstractmethod__ = True ;
  super ( ) . __init__ ( callable ) ;
 }
 ;
}
;
class abstractproperty (   property ) :
{
 __isabstractmethod__ = True ;
}
;
class ABCMeta (   type ) :
{
 _abc_invalidation_counter = 0 ;
 def __new__ (
    mcls
 ,  name
 ,  bases
 ,  namespace
 
 ) :
 {
  cls = super ( ) . __new__ ( mcls , name , bases , namespace ) ;
  abstracts = { name for name , value in namespace . items ( ) if getattr ( value , "__isabstractmethod__" , False ) } ;
  for    base in    bases :
  {
   for    name in    getattr ( base , "__abstractmethods__" , set ( ) ) :
   {
    value = getattr ( cls , name , None ) ;
    if getattr ( value , "__isabstractmethod__" , False ) :
    {
     abstracts . add ( name ) ;
    }
    ;
   }
   ;
  }
  ;
  cls . __abstractmethods__ = frozenset ( abstracts ) ;
  cls . _abc_registry = WeakSet ( ) ;
  cls . _abc_cache = WeakSet ( ) ;
  cls . _abc_negative_cache = WeakSet ( ) ;
  cls . _abc_negative_cache_version = ABCMeta . _abc_invalidation_counter ;
  return    cls ;
 }
 ;
 def register (
    cls
 ,  subclass
 
 ) :
 {
  if not isinstance ( subclass , type ) :
  {
   raise TypeError ( "Can only register classes" )  ;
  }
  ;
  if issubclass ( subclass , cls ) :
  {
   return    subclass ;
  }
  ;
  if issubclass ( cls , subclass ) :
  {
   raise RuntimeError ( "Refusing to create an inheritance cycle" )  ;
  }
  ;
  cls . _abc_registry . add ( subclass ) ;
  ABCMeta . _abc_invalidation_counter += 1 ;
  return    subclass ;
 }
 ;
 def _dump_registry (
    cls
 , file = None
 
 ) :
 {
  """Debug helper to print the ABC registry.""" ;
  print ( "Class: %s.%s" % ( cls . __module__ , cls . __qualname__ ) , file = file ) ;
  print ( "Inv.counter: %s" % ABCMeta . _abc_invalidation_counter , file = file ) ;
  for    name in    sorted ( cls . __dict__ . keys ( ) ) :
  {
   if name . startswith ( "_abc_" ) :
   {
    value = getattr ( cls , name ) ;
    print ( "%s: %r" % ( name , value ) , file = file ) ;
   }
   ;
  }
  ;
 }
 ;
 def __instancecheck__ (
    cls
 ,  instance
 
 ) :
 {
  """Override for isinstance(instance, cls).""" ;
  subclass = instance . __class__ ;
  if subclass in cls . _abc_cache :
  {
   return    True ;
  }
  ;
  subtype = type ( instance ) ;
  if subtype is subclass :
  {
   if ( cls . _abc_negative_cache_version == ABCMeta . _abc_invalidation_counter and subclass in cls . _abc_negative_cache ) :
   {
    return    False ;
   }
   ;
   return    cls . __subclasscheck__ ( subclass ) ;
  }
  ;
  return    any ( cls . __subclasscheck__ ( c ) for c in { subclass , subtype } ) ;
 }
 ;
 def __subclasscheck__ (
    cls
 ,  subclass
 
 ) :
 {
  """Override for issubclass(subclass, cls).""" ;
  if subclass in cls . _abc_cache :
  {
   return    True ;
  }
  ;
  if cls . _abc_negative_cache_version < ABCMeta . _abc_invalidation_counter :
  {
   cls . _abc_negative_cache = WeakSet ( ) ;
   cls . _abc_negative_cache_version = ABCMeta . _abc_invalidation_counter ;
  }
  elif subclass in cls . _abc_negative_cache :
  {
   return    False ;
  }
  ;
  ok = cls . __subclasshook__ ( subclass ) ;
  if ok is not NotImplemented :
  {
   assert isinstance ( ok , bool )  ;
   if ok :
   {
    cls . _abc_cache . add ( subclass ) ;
   }
   else :
   {
    cls . _abc_negative_cache . add ( subclass ) ;
   }
   ;
   return    ok ;
  }
  ;
  if cls in getattr ( subclass , '__mro__' , ( ) ) :
  {
   cls . _abc_cache . add ( subclass ) ;
   return    True ;
  }
  ;
  for    rcls in    cls . _abc_registry :
  {
   if issubclass ( subclass , rcls ) :
   {
    cls . _abc_cache . add ( subclass ) ;
    return    True ;
   }
   ;
  }
  ;
  for    scls in    cls . __subclasses__ ( ) :
  {
   if issubclass ( subclass , scls ) :
   {
    cls . _abc_cache . add ( subclass ) ;
    return    True ;
   }
   ;
  }
  ;
  cls . _abc_negative_cache . add ( subclass ) ;
  return    False ;
 }
 ;
}
;
class ABC (   metaclass = ABCMeta ) :
{
 pass ;
}
;
def get_cache_token (
) :
{
 return    ABCMeta . _abc_invalidation_counter ;
}
;
Reply
#2
  • I think that quite a few people actually like Python as it is - besides, it enforces indent discipline. And I have seen code with lousy indents - in C, bash, and more.
  • Python 3.x is the future
  • I hated the way your code looks (OK, that's me). Part of the beauty of Python - it's concise.
  • "I don't like how the code looks" is a poor excuse to mangle popular and successful language, again - my personal opinion
  • If you ever use Python professionally, and try this stint - you'll lose your job quickly

My 2 cents. I personally like Python style much more than C style.
Test everything in a Python shell (iPython, Azure Notebook, etc.)
  • Someone gave you an advice you liked? Test it - maybe the advice was actually bad.
  • Someone gave you an advice you think is bad? Test it before arguing - maybe it was good.
  • You posted a claim that something you did not test works? Be prepared to eat your hat.
Reply
#3
nix nix (on braces) (from long time C and C++ programmer)
Reply
#4
Volcano63

The braces view is purely for anyone wanting to view/edit raw python in braces format. Nobody else would know that a user has done that. The files are saved as indented python when the user is finished. My boss would never find out.
Reply
#5
(Apr-30-2017, 04:00 PM)michaelcollier Wrote: Volcano63

The braces view is purely for anyone wanting to view/edit raw python in braces format.
  • Will it run in any decent IDE?
  • How easy it will be to debug?
  • If you get used to that abomination Hand - how could you be successful receiver - or contributor - in code reviews?

Of course, it's your funeral Naughty - but for me personally Python style after several years of C/C++ was a source of joy Heart
Test everything in a Python shell (iPython, Azure Notebook, etc.)
  • Someone gave you an advice you liked? Test it - maybe the advice was actually bad.
  • Someone gave you an advice you think is bad? Test it before arguing - maybe it was good.
  • You posted a claim that something you did not test works? Be prepared to eat your hat.
Reply
#6
(Apr-30-2017, 03:21 PM)michaelcollier Wrote: does anyone use it?
No do not want braces at all Angry

Side bye side of your mess and Python code Wink
[Image: b4IEAc.jpg]
Reply
#7
(Apr-30-2017, 04:07 PM)snippsat Wrote: Side bye side of your mess and Python code Wink

Size matters Dance
Test everything in a Python shell (iPython, Azure Notebook, etc.)
  • Someone gave you an advice you liked? Test it - maybe the advice was actually bad.
  • Someone gave you an advice you think is bad? Test it before arguing - maybe it was good.
  • You posted a claim that something you did not test works? Be prepared to eat your hat.
Reply
#8
I understand what you mean, the layout I posted uses the most amount of lines because {} get their own lines and so does a semicolon. Each parameter is also given its own line. If I changed the output format (a feature I haven't finished yet) then it would be more concise.
Reply
#9
Though I see this as a way to teach yourself Python, I don't see any practical use for it.
If it ain't broke, I just haven't gotten to it yet.
OS: Windows 10, openSuse 42.3, freeBSD 11, Raspian "Stretch"
Python 3.6.5, IDE: PyCharm 2018 Community Edition
Reply
#10
I guess the consensus among python programmers is that they don't want braces. I use both methods myself, braces in my own editor, indentation in IDLE. Most of my programming is for microcontrollers so I'm more C/C++ oriented. Hitting the keyboard with {}; is instinctive to me, whereas indentation causes me to slow down a bit. I first got the idea of offering braces when I found this "from __future__ import braces" so I thought I'd give it a go. Thanks for your replies..
Reply


Possibly Related Threads…
Thread Author Replies Views Last Post
  How to output set items without the curly braces ? jimthecanadian 3 2,913 May-11-2019, 07:02 AM
Last Post: perfringo
  search and replace dots inside curly braces kchinnam 1 2,642 May-01-2018, 06:53 PM
Last Post: Larz60+
  No curly braces in python? RedSkeleton007 9 9,157 Jul-28-2017, 11:01 AM
Last Post: tony1812
  JSON API / no braces marucho21 1 3,876 Feb-01-2017, 07:35 AM
Last Post: snippsat

Forum Jump:

User Panel Messages

Announcements
Announcement #1 8/1/2020
Announcement #2 8/2/2020
Announcement #3 8/6/2020