ceth-x86

class Meta(type):
    def __new__(meta, name, bases, class_dict):
        for key, value in class_dict.items():
            if isinstance(value, Field):
                value.name = key
                value.internal_name = '_' + key

        cls = type.__new__(meta, name, bases, class_dict)
        return cls

ceth-x86

class BetterSerializable(object):
    def __init__(self, *args):
        self.args = args

    def serialize(self):
        return json.dumps({
            'class': self.__class__.__name__,
            'agrs': self.args,
        })

ceth-x86

class ValidatePolygon(type):
    def __new__(meta, name, bases, class_dict):
        if bases != (object,):
            if class_dict['sides'] < 3:
                raise ValueError
        return type.__new__(meta, name, bases, class_dict)

class Ploygon(object, metaclass=ValidatePolygon):
    sides = None

ceth-x86

class FixedResistance(Resistor):

    @property
    def ohms(self):
        return self._ohms
        
    @ohms.setter
    def ohms(self, ohms):
        if hasattr(self, '_ohms'):
            raise AttributeError("Невозможно установить атрибут")

ceth-x86

from collections import UserDict

class distinctdict(UserDict):
    def __setitem__(self, key, value):
        if value in self.values():
            if ((key in self and self[key] != value) or key not in self):
                raise DistinctError("This value already exists for different key")
        super().__setitem__(key, value)

ceth-x86

class ToDictMixin(object):
    def to_dict(self):
        return self._traverse_dict(self.__dict__)

    def _traverse_dict(self, instance_dict):
        output = {}
        for key, value in instance_dict.items():
            output[key] = self._traverse(key, value)
        return output

ceth-x86

import os

class GenericInputData(object):
    def read(self):
        raise NotImplementedError

    @classmethod
    def generate_inputs(cls, config):
        raise NotImplementedError

ceth-x86

namespace LoggingDemo.Commands
{
    public interface ICommand
    {
        void Execute();
    }
    
    public interface ICommandFactory
    {
        string CommandName { get; }

ceth-x86

package main

import (
	"fmt"
	"sync"
	"time"
)

func merger(a chan int, b chan int) chan int {

ceth-x86

package main

import (
	"fmt"
	"sync"
	"time"
)

func joiner(inputs []chan string) chan string {